Crear tablas con particiones

En esta página se explica cómo crear tablas con particiones en BigQuery. Si quieres obtener una descripción general de las tablas con particiones, consulta la introducción a las tablas con particiones.

Permisos obligatorios

Para poder crear tablas, como mínimo debes tener los siguientes permisos:

  • Permisos de bigquery.tables.create para crear la tabla
  • bigquery.tables.updateData para escribir datos en la tabla mediante una tarea de carga, una tarea de consulta o un trabajo de copia
  • bigquery.jobs.create para ejecutar una tarea de consulta, cargar tarea o copiar tarea que escriba datos en la tabla.

Puede que se necesiten permisos adicionales, como bigquery.tables.getData, para acceder a los datos que estás escribiendo en la tabla.

Los siguientes roles de gestión de identidades y accesos predefinidos incluyen los permisos bigquery.tables.create y bigquery.tables.updateData:

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

Los siguientes roles de gestión de identidades y accesos predefinidos incluyen los permisos de bigquery.jobs.create:

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

Además, si un usuario tiene los permisos bigquery.datasets.create, cuando ese usuario cree un conjunto de datos, se le concederá acceso de bigquery.dataOwner. El acceso bigquery.dataOwner permite al usuario crear y actualizar tablas en el conjunto de datos.

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta el artículo sobre funciones y permisos predefinidos.

Crear una tabla con particiones vacía

Los pasos para crear una tabla con particiones en BigQuery son similares a los de las tablas estándares; la única diferencia es que se especifican las opciones de partición y las demás opciones de las tablas.

Crear una tabla con particiones por columnas de unidades de tiempo

Para crear una tabla vacía con particiones por columnas de unidades de tiempo con una definición de esquema:

Consola

  1. Abre la página de BigQuery en la consola de Cloud.

    Ir a la página de BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

  3. Abre la opción Acciones y haz clic en Abrir.

  4. En el panel de detalles, haz clic en Crear tabla .

  5. En la página Crear tabla, ve a la sección Fuente y selecciona Tabla vacía.

  6. En la sección Destino:

    • En Nombre del conjunto de datos, elige el conjunto de datos adecuado.
    • En el campo Nombre de la tabla, introduce el nombre de la tabla.
    • Verifica que el Tipo de tabla sea Tabla nativa.

  7. En la sección Schema (Esquema), introduce la definición del esquema. Asegúrate de que el esquema incluya la columna DATE, TIMESTAMP o DATETIME de la columna de particiones. Para obtener más información, consulta el apartado sobre cómo especificar un esquema.

  8. En la sección Partición y configuración del clúster, en la lista desplegable Partición, selecciona Partición por campo y elige la opción de partición. Esta opción solo está disponible si el esquema contiene las columnas DATE, TIMESTAMP o DATETIME.

  9. Selecciona el tipo de partición para elegir una partición diaria, por hora, mensual o anual.

  10. (Opcional) Para aplicar un filtro de partición en todas las consultas de esta tabla, marca la casilla Requerir filtro de partición. Solicitar un filtro de partición puede reducir el coste y mejorar el rendimiento. Para obtener más información, lee sobre cómo consultar tablas con particiones.

  11. Haz clic en Crear tabla.

SQL

Para crear una tabla con particiones por columnas de unidades de tiempo, usa la declaración CREATE TABLE con una cláusula PARTITION BY.

En el ejemplo siguiente se crea una tabla con particiones diarias basadas en la columna transaction_date.

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

El tipo de partición predeterminado de las columnas DATE es la partición diaria. Si quieres especificar otro tipo de partición, incluye la función DATE_TRUNC en la cláusula PARTITION BY. Por ejemplo, la siguiente consulta crea una tabla con particiones mensuales:

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
)

También puedes especificar una columna TIMESTAMP o DATETIME como la columna de partición. En ese caso, incluye la función TIMESTAMP_TRUNC o DATETIME_TRUNC en la cláusula PARTITION BY para especificar el tipo de partición. Por ejemplo, la siguiente declaración crea una tabla con particiones diarias basadas en una columna TIMESTAMP:

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
)

Para saber cómo ejecutar consultas, consulta Ejecutar consultas interactivas.

bq

Usa el comando bq mk con la marca --table (o el acceso directo de -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

Haz los cambios siguientes:

  • SCHEMA: una definición de esquema con formato column:data_type,column:data_type o la ruta a un archivo de esquema JSON de tu máquina local. Para obtener más información, consulta el apartado sobre cómo especificar un esquema.
  • COLUMN: el nombre de la columna de partición. En el esquema de la tabla, esta columna debe ser de tipo TIMESTAMP, DATETIME o DATE.
  • UNIT_TIME: el tipo de partición. Se admiten los siguientes valores: DAY, HOUR, MONTH o YEAR.
  • EXPIRATION_TIME: el tiempo de vencimiento de las particiones de la tabla, expresado en segundos. La marca --time_partitioning_expiration es opcional.
  • BOOLEAN: si es true, las consultas de esta tabla deben incluir un filtro de partición. La marca --require_partition_filter es opcional.
  • PROJECT_ID: el ID del proyecto. Si se omite, se usa el proyecto predeterminado.
  • DATASET: el nombre de un conjunto de datos de tu proyecto.
  • TABLE: el nombre de la tabla que se va a crear.

Para conocer otras opciones de línea de comandos, consulta bq mk.

En el siguiente ejemplo se crea una tabla llamada mytable que se particion según la columna ts y que usa particiones por hora. La caducidad de la partición es de 259.200 segundos (3 días).

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

Llama al método tables.insert con un recurso de tabla definido que especifica la propiedad timePartitioning y la propiedad schema.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go de la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery Go. 

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

Antes de realizar esta muestra, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de BigQuery. 

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

Antes de probar este ejemplo, sigue las instrucciones de configuración de Node.js de la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Node.js de BigQuery. 

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

Antes de probar este ejemplo, sigue las instrucciones de configuración de Python en la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Python para BigQuery. 

# 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
    )
)

Crear una tabla con particiones por hora de ingestión

Para crear una tabla con particiones por tiempo de ingestión vacía con una definición de esquema, sigue estos pasos:

Consola

  1. Abre la página de BigQuery en la consola de Cloud.

    Ir a la página de BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

  3. Abre la opción Acciones y haz clic en Abrir.

  4. En el panel de detalles, haz clic en Crear tabla .

  5. En la página Crear tabla, ve a la sección Fuente y selecciona Tabla vacía.

  6. En la sección Destino:

    • En Nombre del conjunto de datos, elige el conjunto de datos adecuado.
    • En el campo Nombre de la tabla, introduce el nombre de la tabla.
    • Verifica que el Tipo de tabla sea Tabla nativa.

  7. En la sección Schema (Esquema), introduce la definición de schema.

  8. En la sección Configuración de clústeres y clústeres, en Partición, haz clic en Partición por tiempo de ingestión.

  9. (Opcional) Para aplicar un filtro de partición en todas las consultas de esta tabla, marca la casilla Requerir filtro de partición. Solicitar un filtro de partición puede reducir el coste y mejorar el rendimiento. Para obtener más información, lee sobre cómo consultar tablas con particiones.

  10. Haz clic en Crear tabla.

SQL

Si quieres crear una tabla con particiones por hora de ingestión, usa laCREATE TABLE declaración con un elementoPARTITION BY cláusula que las particiones de_PARTITIONTIME en tu teléfono Android.

En el siguiente ejemplo se crea una tabla con particiones diarias.

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

El tipo de partición predeterminado para la partición del tiempo de ingestión es la división diaria. Si quieres especificar otro tipo de partición, incluye la función DATE_TRUNC en la cláusula PARTITION BY. Por ejemplo, la siguiente consulta crea una tabla con particiones mensuales:

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

Para saber cómo ejecutar consultas, consulta Ejecutar consultas interactivas.

bq

Usa el comando bq mk con la marca --table (o el acceso directo de -t):

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

Haz los cambios siguientes:

  • SCHEMA: una definición con el formato column:data_type,column:data_type o la ruta a un archivo de esquema JSON de tu máquina local. Para obtener más información, consulta el apartado sobre cómo especificar un esquema.
  • UNIT_TIME: el tipo de partición. Se admiten los siguientes valores: DAY, HOUR, MONTH o YEAR.
  • EXPIRATION_TIME: el tiempo de vencimiento de las particiones de la tabla, expresado en segundos. La marca --time_partitioning_expiration es opcional.
  • BOOLEAN: si es true, las consultas de esta tabla deben incluir un filtro de partición. La marca --require_partition_filter es opcional.
  • PROJECT_ID: el ID del proyecto. Si se omite, se usa el proyecto predeterminado.
  • DATASET: el nombre de un conjunto de datos de tu proyecto.
  • TABLE: el nombre de la tabla que se va a crear.

Para conocer otras opciones de línea de comandos, consulta bq mk.

En el ejemplo siguiente se crea una tabla con particiones por hora de ingestión con el nombre mytable. La tabla tiene particiones diarias, con una caducidad de 259.200 segundos (3 días).

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

API

Llama al método tables.insert con un recurso de tabla definido que especifica la propiedad timePartitioning y la propiedad schema.

Crear una tabla con particiones de rangos de números enteros

Para crear una tabla con particiones de números enteros vacía con una definición de esquema, sigue estos pasos:

Consola

  1. Abre la página de BigQuery en la consola de Cloud.

    Ir a la página de BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

  3. Abre la opción Acciones y haz clic en Abrir.

  4. En el panel de detalles, haz clic en Crear tabla .

  5. En la página Crear tabla, ve a la sección Fuente y selecciona Tabla vacía.

  6. En la sección Destino:

    • En Nombre del conjunto de datos, elige el conjunto de datos adecuado.
    • En el campo Nombre de la tabla, introduce el nombre de la tabla.
    • Verifica que el Tipo de tabla sea Tabla nativa.

  7. En la sección Schema (Esquema), introduce la definición del esquema. El esquema debe incluir la columna INTEGER correspondiente a la columna de partición. Para obtener más información, consulta el apartado sobre cómo especificar un esquema.

  8. En la sección Partición y configuración del clúster, en la lista desplegable Partición, selecciona Partición por campo y elige la opción de partición. Esta opción solo está disponible si el esquema contiene una columna INTEGER.

  9. Proporcione valores para Inicio, Fin e Intervalo:

    • Start es el comienzo del primer intervalo de partición (inclusive).
    • Fin es el final del último intervalo de partición (exclusivo).
    • Lote es la anchura de cada intervalo de particiones.

    Los valores que se encuentran fuera de estos intervalos se dividen en una división especial __UNPARTITIONED__.

  10. (Opcional) Para aplicar un filtro de partición en todas las consultas de esta tabla, marca la casilla Requerir filtro de partición. Solicitar un filtro de partición puede reducir el coste y mejorar el rendimiento. Para obtener más información, lee sobre cómo consultar tablas con particiones.

  11. Haz clic en Crear tabla.

SQL

Para crear una tabla con particiones por intervalos de números enteros, usa la instrucción CREATE TABLE con una cláusula PARTITION BY.

En el ejemplo siguiente se crea una tabla que tiene particiones en la columna customer_id con los inicios de 0, 100 y 100.

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
)

Para saber cómo ejecutar consultas, consulta Ejecutar consultas interactivas.

bq

Usa el comando bq mk con la marca --table (o el acceso directo de -t):

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

Haz los cambios siguientes:

  • SCHEMA: una definición de esquema en línea con el formato column:data_type,column:data_type o la ruta a un archivo de esquema JSON de tu máquina local. Para obtener más información, consulta el apartado sobre cómo especificar un esquema.
  • COLUMN_NAME: el nombre de la columna de partición. En el esquema de la tabla, esta columna debe ser de tipo INTEGER.
  • START: el primer intervalo de partición (incluido).
  • END: el final del último intervalo de partición (exclusivo).
  • INTERVAL: el ancho de cada intervalo de particiones.
  • BOOLEAN: si es true, las consultas de esta tabla deben incluir un filtro de partición. La marca --require_partition_filter es opcional.
  • PROJECT_ID: el ID del proyecto. Si se omite, se usa el proyecto predeterminado.
  • DATASET: el nombre de un conjunto de datos de tu proyecto.
  • TABLE: el nombre de la tabla que se va a crear.

Los valores que se encuentran fuera del intervalo de partición se dividen en una partición __UNPARTITIONED__ especial.

Para conocer otras opciones de línea de comandos, consulta bq mk.

En el siguiente ejemplo se crea una tabla llamada mytable que se divide en la columna customer_id.

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

API

Llama al método tables.insert con un recurso de tabla definido que especifica la propiedad rangePartitioning y la propiedad schema.

Java

Antes de realizar esta muestra, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de BigQuery. 

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

Antes de probar este ejemplo, sigue las instrucciones de configuración de Node.js de la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Node.js de BigQuery. 

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

Antes de probar este ejemplo, sigue las instrucciones de configuración de Python en la guía de inicio rápido de BigQuery sobre el uso de bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Python para BigQuery. 

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

Crear una tabla con particiones a partir de un resultado de consulta

Puedes crear una tabla con particiones a partir de un resultado de consulta de las siguientes maneras:

  • Usa la herramienta de línea de comandos bq o la API de BigQuery para establecer una tabla de destino para una consulta. Cuando se ejecuta la consulta, BigQuery escribe los resultados en la tabla de destino. Puedes usar esta estrategia para cualquier tipo de partición.

  • En SQL, usa una declaración CREATE TABLE ... AS SELECT. Puedes seguir este método para crear una tabla con particiones por columnas de unidades de tiempo o por números enteros, pero no por tiempo de ingestión.

SQL

Usa la instrucción CREATE TABLE con una cláusula SELECT AS para la consulta. Incluye una cláusula PARTITION BY para configurar la partición.

En el siguiente ejemplo se crea una tabla que se divide en la columna transaction_date.

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

bq

Para crear una tabla con particiones a partir de una consulta, usa el comando bq query con la marca --destination_table y la marca --time_partitioning_type.

Partición de columnas de unidades de tiempo:

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

Partición en el momento de la ingestión:

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

Partición de intervalos de números enteros:

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

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto. Si se omite, se usa el proyecto predeterminado.
  • DATASET: el nombre de un conjunto de datos de tu proyecto.
  • TABLE: el nombre de la tabla que se va a crear.
  • COLUMN: el nombre de la columna de partición.
  • UNIT_TIME: el tipo de partición. Se admiten los siguientes valores: DAY, HOUR, MONTH o YEAR.
  • START: el inicio de la partición de intervalos, ambos incluidos.
  • END: fin de la partición del intervalo, exclusivo.
  • INTERVAL: el ancho de cada intervalo dentro de la partición.
  • QUERY_STATEMENT: la consulta utilizada para rellenar la tabla.

En el siguiente ejemplo se crea una tabla que se divide en la columna transaction_date con las particiones mensuales.

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

En el ejemplo siguiente se crea una tabla que se divide en la columna customer_id con partición de intervalos de números enteros.

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

En el caso de las tablas con particiones por hora de ingestión, también puedes cargar datos en una partición concreta con una decoración de particiones. En el siguiente ejemplo se crea una tabla con particiones por hora de ingestión y se cargan los datos en la partición 20180201 (1 de febrero del 2018):

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

API

Para guardar los resultados de las consultas en una tabla con particiones, llama al método jobs.insert. Configura una tarea query. Especifica la tabla de destino en destinationTable. Indica la partición en la propiedad timePartitioning o en la propiedad rangePartitioning.

Escribir datos en una partición concreta

Los decoradores de particiones te permiten escribir datos en una partición concreta. Una decorador tiene la siguiente forma:

table_name$partition_id

En el siguiente ejemplo se escriben datos en la partición 20160501 (1 de mayo del 2016) de una tabla disponible, suponiendo que la tabla ya se haya particiones por fecha:

bq load --source_format=CSV 'mydataset.mytable$20160501' data.csv

También puedes escribir los resultados de una consulta en una partición concreta:

bq query \
  --use_legacy_sql=false  \
  --destination_table='mytable$20160501' \
  --append_table=true \
  'SELECT * FROM mydataset.another_table'

Con la partición en el momento de la ingestión, puedes usar esta técnica para cargar datos anteriores o para ajustar las zonas horarias. Por ejemplo, si estás en la hora estándar del Pacífico (PST), puedes usar el decorador de partición correspondiente para cargar los datos generados el 1 de mayo del 2016 PST en la partición de esa fecha. $20160501. De forma predeterminada, las particiones de tiempo de ingestión se basan en la hora UTC.

En las tablas con particiones por columnas y intervalos de números enteros, el ID de partición especificado en el decorador debe coincidir con los datos que se van a escribir. Por ejemplo, si la tabla se divide en una columna DATE, el decorador debe coincidir con el valor de esa columna. De lo contrario, se produce un error. Sin embargo, si sabes que tus datos se encuentran en una sola partición, puedes especificar que el decorador de particiones puede mejorar el rendimiento de escritura.

Para obtener más información sobre cómo cargar datos, consulta la introducción a la carga de datos en BigQuery.

Convertir tablas fragmentadas con fecha en tablas con particiones por hora de ingestión

Si ya has creado tablas con fecha, puedes convertir el conjunto completo de tablas relacionadas en una sola tabla con particiones por hora de ingestión mediante el comando partition en la herramienta de línea de comandos bq.

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

Haz los cambios siguientes:

  • LOCATION: el nombre de tu ubicación. La marca --location es opcional.
  • PARTITION_TYPE: el tipo de partición. Los valores posibles son DAY, HOUR, MONTH o YEAR.
  • INTEGER: tiempo de vencimiento de la partición, expresado en segundos. No hay un valor mínimo. El tiempo de vencimiento se evalúa para la fecha UTC de la partición y el valor entero. La marca time_partitioning_expiration es opcional.
  • PROJECT_ID: el ID del proyecto.
  • SOURCE_DATASET: el conjunto de datos que contiene las tablas fragmentadas con fecha.
  • SOURCE_TABLE: el prefijo de las tablas fragmentadas con fecha.
  • DESTINATION_DATASET El conjunto de datos de la nueva tabla con particiones.
  • DESTINATION_TABLE El nombre de la tabla con particiones que se creará.

El comando partition no admite las marcas --label, --expiration ni --description. Puedes añadir etiquetas, una fecha de vencimiento y una descripción de la tabla una vez que se haya creado.

Al ejecutar el comando partition, BigQuery crea una tarea de copia que genera particiones a partir de las tablas fragmentadas.

En el ejemplo siguiente se crea una tabla con particiones por hora de ingestión denominada mytable_partitioned a partir de un conjunto de tablas fragmentadas con fecha y con el prefijo sourcetable_. La tabla nueva tiene particiones cada día, con una terminación de 259.200 segundos (3 días).

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

Si las tablas fragmentadas en la fecha eran sourcetable_20180126 y sourcetable_20180127, el comando crearía las siguientes particiones: mydataset.mytable_partitioned$20180126 y mydataset.mytable_partitioned$20180127.

Pasos siguientes