Crea y usa tablas particionadas por rango de números enteros

En este documento, se describe cómo crear y usar tablas particionadas por una columna entera. Para obtener información sobre otros tipos de tablas particionadas, consulta Cómo crear y usar tablas particionadas o la sección sobre cómo crear y usar tablas particionadas por tiempo de transferencia.

Para obtener información adicional sobre particiones de rango entero, consulta Introducción a las tablas particionadas.

Después de crear una tabla particionada de rango entero, puedes hacer lo siguiente:

  • Controlar el acceso a los datos de tu tabla
  • Obtener información acerca de tus tablas particionadas
  • Ver una lista de las tablas particionadas en un conjunto de datos
  • Obtener metadatos de tablas particionadas por medio de metatablas

Para obtener más información sobre cómo administrar tablas particionadas, lo que incluye cómo copiarlas, borrarlas y actualizar sus propiedades, consulta Administra tablas particionadas.

Limitaciones

Las tablas particionadas por rango de números enteros están sujetas a las siguientes limitaciones:

  • La columna de partición debe ser una columna INTEGER. El modo de la columna puede ser REQUIRED o NULLABLE, pero no puede ser REPEATED (basada en arreglo).
  • La columna de partición debe ser un campo de nivel superior. No puedes usar un campo de hoja de un RECORD (STRUCT) como columna de partición.
  • No puedes usar SQL heredado para realizar consultas en las tablas particionadas ni para escribir resultados de consultas en ellas.

Crea tablas particionadas

Tienes las siguientes opciones para crear una tabla particionada con un rango de números enteros en BigQuery:

  • Usar Cloud Console o la IU web clásica
  • Mediante una declaración DDL CREATE TABLE con una cláusula PARTITION BY RANGE_BUCKET que contenga una partition expression
  • Mediante el uso del comando bq mk de la herramienta de línea de comandos de bq
  • De manera programática, con una llamada al método tables.insert de la API
  • A partir de resultados de consulta
  • Hacerlo cuando cargas datos

Nombres de las tablas

Cuando creas una tabla en BigQuery, el nombre de la tabla debe ser único en cada conjunto de datos. El nombre de la tabla tiene las siguientes características:

  • Contiene hasta 1,024 caracteres
  • Contener letras (mayúsculas o minúsculas), números y guiones bajos

Permisos necesarios

Como mínimo, para crear una tabla, debes tener los siguientes permisos:

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

Es posible que se necesiten permisos adicionales, como bigquery.tables.getData, para acceder a los datos que escribes en la tabla.

En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.create y bigquery.tables.updateData:

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

Las siguientes funciones predefinidas de IAM incluyen los permisos bigquery.jobs.create:

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

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. Con el acceso bigquery.dataOwner, el usuario puede crear y actualizar tablas en el conjunto de datos.

Para obtener más información sobre las funciones y los permisos de IAM en BigQuery, consulta Funciones y permisos predefinidos.

Crea una tabla particionada vacía con una definición de esquema

No puedes crear una tabla particionada vacía que no tenga una definición de esquema. Se requiere el esquema a fin de identificar la columna que se usó para crear las particiones.

Cuando creas una tabla particionada vacía con una definición de esquema, puedes hacer lo siguiente:

  • Proporcionar el esquema intercalado mediante la herramienta de línea de comandos de bq
  • Especificar un archivo de esquema JSON mediante la herramienta de línea de comandos de bq
  • Proporcionar el esquema en un recurso de tabla cuando llames al método tables.insert de la API

Si quieres obtener más información acerca de cómo especificar un esquema de tabla, consulta Instrucciones para especificar un esquema.

Una vez que se crea la tabla particionada, puedes hacer lo siguiente:

  • Cargar datos en la tabla
  • Escribir resultados de consultas
  • Copiar datos en la tabla

Para crear una tabla particionada vacía con una definición de esquema, sigue estos pasos:

Console

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

    Ir a la página BigQuery

  2. En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona el conjunto de datos.

  3. En el lado derecho de la ventana, en el panel de detalles, haz clic en Crear tabla.

  4. En la sección Fuente del panel Crear tabla, sigue estos pasos:

    • En Crear tabla a partir de, selecciona Tabla vacía.
  5. En la sección Destino, sigue estos pasos:

    • Para el Nombre del conjunto de datos, selecciona el conjunto de datos apropiado y en el campo Nombre de la tabla, escribe el nombre de la tabla que creaste.
    • Verifica que Tipo de tabla esté establecido en Tabla nativa.
  6. En la sección Esquema, ingresa la definición del esquema.

    • Ingresa la información del esquema de forma manual de la siguiente manera:

      • Habilita Editar como texto y, luego, ingresa el esquema de la tabla como un arreglo JSON.

      • Usa Agregar campo para ingresar el esquema de forma manual.

  7. En Configuración de partición y agrupamiento en clústeres, en la lista desplegable Partición, elige una columna de tipo INTEGER.

  8. Proporciona valores de inicio, de fin y de intervalo:

    • start es el inicio de la partición por rango, inclusivo.
    • end es el final de la partición por rango, exclusivo.
    • interval es el ancho de cada rango dentro de la partición.
  9. Para el Filtro de partición, haz clic en la casilla Exigir filtro de partición a fin de solicitar a los usuarios que incluyan una cláusula WHERE que especifique las particiones que deben consultarse (opcional). Exigir un filtro de partición puede reducir los costos y mejorar el rendimiento. Para obtener más información, lee la sección Cómo consultar tablas particionadas.

  10. De manera opcional, si deseas usar una clave de Cloud Key Management Service, haz clic en Opciones avanzadas y selecciona Clave administrada por el cliente en Encriptación. Si dejas establecida la configuración Clave administrada por Google, BigQuery encripta los datos en reposo.

  11. Haz clic en Crear tabla.

DDL

Las declaraciones del lenguaje de definición de datos (DDL) te permiten crear y modificar tablas y vistas con la sintaxis de consulta de SQL estándar.

Obtén más información en Usa instrucciones del lenguaje de definición de datos.

Sigue estos pasos para crear una tabla particionada con una declaración DDL en Cloud Console:

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

    Ir a la página de BigQuery

  2. Haz clic en Redactar consulta nueva.

  3. Escribe tu declaración CREATE TABLE de DDL en el área de texto del Editor de consultas.

    La siguiente consulta crea una tabla llamada newtable con una partición de rango entero en la columna customer_id con inicio 0, intervalo 10 y fin 100.

     CREATE TABLE
       mydataset.newtable
     PARTITION BY
       RANGE_BUCKET(customer_id, GENERATE_ARRAY(0, 100, 10))
     AS SELECT 1 AS customer_id, DATE "2019-10-01" AS date1
     

  4. Haz clic en Ejecutar. Cuando se complete la consulta, aparecerá la tabla en el panel Recursos.

bq

Usa el comando mk con la marca --range_partitioning:

bq mk \
--range_partitioning=column_name,start,end,interval \
project_id:dataset.table \
"column_name:integer,value:integer"

En el ejemplo anterior, se ilustra lo siguiente:

  • column_name es la columna que se usó para crear las particiones por rango de números enteros.
  • start es el inicio de la partición por rango, inclusivo.
  • end es el final de la partición por rango, exclusivo.
  • interval es el ancho de cada rango dentro de la partición.
  • project_id es el ID del proyecto.
  • dataset es un conjunto de datos en tu proyecto.
  • table es el nombre de la tabla particionada que creas.

Ejemplos:

Ingresa el siguiente comando para crear una tabla particionada por rango entero llamada mypartitionedtable en mydataset en tu proyecto predeterminado. La partición se basa en un inicio de 0, un fin de 100 y un intervalo de 10.

Se usa la marca --require_partition_filter a fin de solicitar a los usuarios que incluyan una cláusula WHERE que especifique las particiones que deben consultarse. Exigir un filtro de partición puede reducir los costos y mejorar el rendimiento. Para obtener más información, lee la sección Consulta tablas particionadas.

bq mk \
--require_partition_filter \
--range_partitioning=customer_id,0,100,10 \
mydataset.mypartitionedtable \
"customer_id:integer,value:integer"

Después de crear la tabla, puedes usar la herramienta de línea de comandos de bq para actualizar el vencimiento de la tabla, el vencimiento de la partición, la descripción y las etiquetas de la tabla particionada.

API

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

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

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 para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

// 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 esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

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

Para verificar si una tabla está particionada en una columna de números enteros, examina el esquema. Por ejemplo, ejecuta el siguiente comando:

bq show --format=prettyjson mydataset.mytable

Si una columna entera está particionada, el resultado de bq show contendrá datos de rangePartitioning:

...
  "rangePartitioning": {
    "field": "customer_id",
    "range": {
      "end": "100",
      "interval": "10",
      "start": "0"
    }
  },
...

Escribe una tabla particionada de rango entero

Los datos que se escriben en una tabla particionada de rango entero se particionan de forma automática. Esto incluye escribir una tabla a través de trabajos de carga, consultas y transmisiones.

En las transmisiones, los datos en el búfer de transmisión están en la partición UNPARTITIONED. Cuando se extraen los datos, en un principio permanecen en la partición UNPARTITIONED. Cuando haya suficientes datos no particionados, se volverán a particionar en particiones específicas.

A continuación, se muestra un ejemplo sobre cómo guardar los resultados de la consulta en una tabla particionada de rango entero:

bq query --nouse_legacy_sql \
--destination_table=mydataset.mytable \
'SELECT value AS customer_id, value+1 AS value FROM UNNEST(GENERATE_ARRAY(-5, 110, 5)) AS value'

Consulta una tabla particionada de rango entero

Las tablas particionadas de rango entero solo pueden consultarse a través de SQL estándar. Cuando se consulta una tabla particionada de rango entero, si hay filtros en la columna de partición entera, estos se usarán para reducir las particiones y el costo de la consulta.

La siguiente consulta analizará las 3 particiones que comienzan con 30, 40 y 50.

bq query --nouse_legacy_sql \
'SELECT * FROM mydataset.mytable WHERE customer_id BETWEEN 30 AND 50'

Aquí hay un resultado de ejemplo del comando bq query:

Waiting on bqjob_r4fce65fa3381528e_000001670994aeb6_1 ... (0s) Current status: DONE
+---------+-------+
| customer_id | value |
+---------+-------+
|      40 |    41 |
|      45 |    46 |
|      30 |    31 |
|      35 |    36 |
|      50 |    51 |
+---------+-------+

En este ejemplo, cada partición tiene dos filas y cada fila tiene dos columnas enteras, por lo que la consulta debería analizar 3 * 2 * 2 * 8 = 96 bytes. Puedes examinar la información del trabajo:

bq show -j bqjob_r4fce65fa3381528e_000001670994aeb6_1

Aquí hay un resultado de ejemplo del comando bq show:

Job myproject:bqjob_r4fce65fa3381528e_000001670994aeb6_1

  Job Type    State      Start Time      Duration       User Email        Bytes Processed   Bytes Billed   Billing Tier   Labels
 ---------- --------- ----------------- ---------- --------------------- ----------------- -------------- -------------- --------
  query      SUCCESS   24 Sep 12:19:58   0:00:01    joe@google.com       96                10485760       1

Las declaraciones DML son compatibles. Por ejemplo:

bq query --nouse_legacy_sql \
'DELETE FROM mydataset.mytable WHERE customer_id = 30'

En este momento, no se admite la reducción de particiones para funciones de más de una columna particionada de rango entero. Por ejemplo, la siguiente consulta analizará toda la tabla.

bq query --nouse_legacy_sql \
'SELECT * FROM mydataset.mytable WHERE customer_id+1 BETWEEN 30 AND 50'

Decoradores de tabla en tablas particionadas de rango entero

De forma similar a la partición por fecha/marca de tiempo, se pueden usar los decoradores de tabla para dirigirse a una partición en una tabla particionada de rango entero. La clave para dirigirse a una partición de rango es el inicio del rango.

El siguiente ejemplo consulta la partición de rango que comienza con 0. Tiene 2 valores, 0 y 5.

bq query 'SELECT * FROM mydataset.mytable$0'

+---------+-------+
| customer_id | value |
+---------+-------+
|       0 |     1 |
|       5 |     6 |
+---------+-------+

Partición de rango entero con agrupamiento en clústeres

Puedes usar una partición de rango entero con agrupamiento en clústeres. Primero, se particionan los datos en la columna particionada de rango entero y, luego, los datos de cada partición se agrupan en las columnas de agrupamiento en clústeres.

A modo de ejemplo, este comando crea una tabla con una columna de rango entero y un clúster.

bq mk \
--range_partitioning=customer_id,0,100,10 \
--clustering_fields=value \
mydataset.mytable_2 \
"customer_id:integer,value:integer"

Cuando recuperes el formato de la tabla, verás que la partición de rango y la agrupación en clústeres están activas:

...
  "clustering": {
    "fields": [
      "value"
    ]
  },
...
  "rangePartitioning": {
    "field": "customer_id",
    "range": {
      "end": "100",
      "interval": "10",
      "start": "0"
    }
  },
...

Crea una tabla particionada a partir de un resultado de consulta

Sigue estos pasos para crear una tabla particionada a partir de un resultado de consulta:

Console

No puedes especificar opciones de partición para una tabla de destino cuando consultas datos con Cloud Console.

bq

Ingresa el comando bq query, especifica la marca --destination_table para crear una tabla permanente basada en los resultados de la consulta y especifica la marca --range_partitioning a fin de crear una tabla de destino particionada.

Especifica la marca use_legacy_sql=false para usar la sintaxis de SQL estándar. Para escribir los resultados de las consultas en una tabla que no se encuentra en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos con el siguiente formato: project_id:dataset.

De forma opcional, puedes proporcionar la marca --location y establecer el valor según tu ubicación.

Ingresa el siguiente comando para crear una tabla de destino particionada nueva a partir de un resultado de consulta:

bq --location=location query \
--destination_table project_id:dataset.table \
--range_partitioning column,start,end,interval \
--use_legacy_sql=false \
'query'

Donde:

  • location es el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la ubicación de Tokio, establece el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • project_id es el ID del proyecto.
  • dataset es el nombre del conjunto de datos que contendrá la tabla particionada nueva.
  • table es el nombre de la tabla particionada que creas por medio de los resultados de la consulta.
  • column es la columna INTEGER que se usará en la partición.
  • start es el inicio de la partición por rango, inclusivo.
  • end es el final de la partición por rango, exclusivo.
  • interval es el ancho de cada rango dentro de la partición.
  • query es una consulta en la sintaxis de SQL estándar. Por el momento, no puedes usar SQL heredado para consultar tablas particionadas ni para escribir resultados de consultas en ellas.

Ejemplo:

Ingresa el siguiente comando para escribir los resultados de la consulta en una tabla de destino particionada llamada mypartitionedtable en mydataset. mydataset está en tu proyecto predeterminado. Esta consulta obtiene datos de una tabla no particionada: el conjunto de datos públicos sobre los accidentes de tráfico fatales de NHTSA. Se usa la columna de INTEGER provider_id de la tabla para crear las particiones.

bq query \
--destination_table mydataset.mypartitionedtable \
--use_legacy_sql=false \
--range_partitioning provider_id,10000,700000,10000 \
'SELECT
   provider_id, total_discharges, average_covered_charges
 FROM
   `bigquery-public-data`.medicare.inpatient_charges_2011
 LIMIT
   300'

API

A fin de guardar los resultados de la consulta en una tabla particionada permanente, llama al método jobs.insert, configura un trabajo query y, luego, incluye un valor para las propiedades destinationTable y rangePartitioning.

Especifica tu ubicación en la propiedad location en la sección jobReference del recurso de trabajo.

Crea una tabla particionada cuando cargues datos

Puedes crear una tabla particionada si especificas opciones de partición cuando cargas datos en una tabla nueva. No es necesario crear una tabla particionada vacía antes de cargarle datos. Puedes crear una tabla particionada y cargar tus datos al mismo tiempo.

Cuando cargas datos en BigQuery, puedes proporcionar el esquema de tabla o puedes usar la detección automática del esquema si el formato de datos es compatible.

Los decoradores de particiones te permiten cargar datos en una partición específica. Por ejemplo, considera una tabla particionada por rango entero en la columna customer_id, con un inicio en 0, un final en 100 y un intervalo de 10. Para cargar todos los datos de ID del cliente que están en el rango de 0 a 9, usa el siguiente decorador de partición $0:

table_name$0

Cuando cargues datos en una partición específica mediante un decorador de particiones, los datos que se carguen en la partición deben concordar con el esquema de partición de la tabla. Todas las filas escritas en la partición deben tener valores que coincidan con la fecha de la partición.

Para obtener más información, consulta Introducción a la carga de datos en BigQuery.

Controla el acceso a las tablas particionadas

Para configurar el acceso a las tablas y vistas, puedes otorgar una función de IAM a una entidad en los siguientes niveles, ordenados según el rango de recursos permitidos (de mayor a menor):

El acceso con cualquier recurso protegido por IAM es aditivo. Por ejemplo, si una entidad no tiene acceso en un nivel alto, como un proyecto, podrías otorgar acceso a la entidad a nivel del conjunto de datos. Luego, la entidad tendrá acceso a las tablas y vistas del conjunto de datos. Del mismo modo, si la entidad no tiene acceso en el nivel alto o en el de conjunto de datos, puedes otorgar acceso a la entidad a nivel de tabla o de vista.

Si otorgas funciones de IAM en un nivel superior en la jerarquía de recursos de Google Cloud, como el nivel de proyecto, de carpeta o de organización, la entidad tiene acceso a un amplio conjunto de recursos. Por ejemplo, cuando se otorga una función a una entidad en el nivel de proyecto, se le brindan permisos que se aplican a todos los conjuntos de datos del proyecto.

Si se otorga una función a nivel de conjunto de datos, se especifican las operaciones que una entidad puede realizar en las tablas y vistas de ese conjunto de datos específico, incluso si la entidad no tiene acceso a un nivel superior. Para obtener información sobre la configuración de los controles de acceso a nivel de conjunto de datos, consulta Controla el acceso a los conjuntos de datos.

Cuando se otorga una función a nivel de tabla o vista, se especifican las operaciones que una entidad puede realizar en las tablas y vistas específicas, incluso si la entidad no tiene acceso a un nivel superior. Para obtener información sobre la configuración de los controles de acceso a nivel de tabla, consulta Controla el acceso a las tablas y vistas.

También puedes crear funciones de IAM personalizadas. Si creas una función personalizada, los permisos que otorgas dependerán de las operaciones específicas que deseas que la entidad pueda realizar.

No puedes establecer un permiso de denegación en ningún recurso protegido por IAM.

Para obtener más información sobre las funciones y los permisos, consulta las siguientes páginas:

Usa tablas particionadas

Obtén información sobre tablas particionadas

Tienes las siguientes opciones para obtener información sobre las tablas:

  • Mediante Cloud Console o la IU web clásica de BigQuery
  • Mediante el comando bq show en la herramienta de línea de comandos de bq
  • Mediante una llamada al método de la API tables.get
  • Usar bibliotecas cliente

Permisos necesarios

Como mínimo, para obtener información sobre las tablas, debes tener permisos bigquery.tables.get. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.get:

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

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. El acceso bigquery.dataOwner le otorga al usuario la capacidad de recuperar los metadatos de la tabla.

Para obtener más información sobre las funciones y los permisos de IAM en BigQuery, consulta Control de acceso.

Obtén información acerca de una tabla particionada

Para ver información sobre una tabla particionada, haz lo siguiente:

Console

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

    Ir a la página BigQuery

  2. En el panel de navegación, en la sección Resources (Recursos), expande tu proyecto y conjunto de datos; luego, haz clic en el nombre de la tabla en la lista.

  3. Haz clic en Details (Detalles) debajo del Query editor (Editor de consultas). En esta pestaña, se muestra la descripción y la información de la tabla.

    Detalles de la tabla

  4. Haz clic en la pestaña Esquema para ver la definición del esquema de la tabla. Ten en cuenta que las tablas particionadas no incluyen la seudocolumna _PARTITIONTIME.

bq

Emite el comando bq show para mostrar toda la información de la tabla. Usa la marca --schema para mostrar solo la información del esquema de la tabla. La marca --format se puede usar para controlar el resultado.

Si quieres obtener información sobre una tabla en un proyecto que no sea tu proyecto predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: project_id:dataset.

bq show --schema --format=prettyjson project_id:dataset.table

En el ejemplo anterior, se ilustra lo siguiente:

  • project_id es el ID del proyecto.
  • dataset es el nombre del conjunto de datos.
  • table es el nombre de la tabla.

Ejemplos:

Ingresa el siguiente comando para mostrar toda la información sobre mytable en mydataset. mydataset está en tu proyecto predeterminado.

bq show --format=prettyjson mydataset.mytable

Ingresa el siguiente comando para mostrar toda la información sobre mytable en mydataset. mydataset está en myotherproject, no en tu proyecto predeterminado.

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

El resultado debería ser similar a lo siguiente:

{
  "creationTime": "1569429717657",
  "etag": "AcSEmWFQdbYEGT0auTE9NA==",
  "id": "myproject:mydataset.newtable",
  "kind": "bigquery#table",
  "lastModifiedTime": "1569429717657",
  "location": "US",
  "numBytes": "16",
  "numLongTermBytes": "0",
  "numRows": "1",
  "rangePartitioning": {
    "field": "customer_id",
    "range": {
      "end": "100",
      "interval": "10",
      "start": "0"
    }
  },
  "schema": {
    "fields": [
      {
        "name": "customer_id",
        "type": "INTEGER"
      },
      {
        "name": "date1",
        "type": "DATE"
      }
    ]
  },
  "selfLink": "https://bigquery.googleapis.com/bigquery/v2/projects/myproject/datasets/mydataset/tables/newtable",
  "tableReference": {
    "datasetId": "mydataset,
    "projectId": "myproject",
    "tableId": "newtable"
  },
  "type": "TABLE"
}

API

Llama al método tables.get y proporciona los parámetros relevantes.

Muestra una lista de las tablas particionadas en un conjunto de datos

Tienes las siguientes opciones para mostrar una lista de las tablas de los conjuntos de datos (incluidas las tablas particionadas):

  • Mediante Cloud Console o la IU web clásica de BigQuery
  • Mediante el comando bq ls en la herramienta de línea de comandos de bq
  • Mediante una llamada al método de la API tables.list
  • Usar bibliotecas cliente

Permisos necesarios

Como mínimo, para enumerar las tablas en un conjunto de datos, debes tener permisos bigquery.tables.list. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.list:

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

Para obtener más información sobre las funciones y los permisos de IAM en BigQuery, consulta Control de acceso.

Obtén una lista de tablas particionadas

Para ver una lista de las tablas de un conjunto de datos (incluidas las tablas particionadas), haz lo siguiente:

Console

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

    Ir a la página BigQuery

  2. En el panel de navegación, en la sección Recursos, expande tu proyecto y haz clic en tu conjunto de datos.

  3. Desplázate por la lista para ver las tablas en el conjunto de datos. Las tablas, las tablas particionadas, los modelos y las vistas se identifican mediante íconos diferentes.

API

Para mostrar una lista de las tablas con la API, realiza una llamada al método tables.list.

Muestra una lista de particiones de tablas

A fin de mostrar la lista de particiones de una tabla particionada, puedes realizar una consulta en la metatabla __PARTITIONS_SUMMARY__ con SQL heredado.

Puedes ejecutar la consulta con Cloud Console, la IU web clásica de BigQuery o el comando bq query en la herramienta de línea de comandos de bq o con una llamada al método jobs.insert para configurar un trabajo query.

Permisos necesarios

Como mínimo, para ejecutar un trabajo de consulta que usa la metatabla __PARTITIONS_SUMMARY__, debes tener permisos bigquery.jobs.create. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.jobs.create:

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

También debes tener permisos bigquery.tables.getData. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.getData:

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

Para obtener más información sobre las funciones de IAM en BigQuery, consulta Control de acceso.

Visualiza la lista de particiones en una tabla particionada

Puedes enumerar las particiones de una tabla particionada mediante SQL heredado. Para hacerlo, sigue estos pasos:

Console

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

    Ir a la página BigQuery

  2. Haz clic en el botón Redactar nueva consulta.

  3. Ingrese el siguiente texto en el cuadro Editor de consulta para consultar la metatabla __PARTITIONS_SUMMARY__:

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

    En el ejemplo anterior, se ilustra lo siguiente:

    • dataset es el conjunto de datos que contiene la tabla.
    • table es el nombre de la tabla.
  4. Haz clic en Ejecutar.

bq

Ingresa la siguiente consulta mediante el comando bq query:

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

En el ejemplo anterior, se ilustra lo siguiente:

  • location es el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la ubicación de Tokio, establece el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • dataset es el conjunto de datos que contiene la tabla.
  • table es el nombre de la tabla.

API

Llama al método jobs.insert y configura un trabajo query que consulte la metatabla __PARTITIONS_SUMMARY__ de la tabla.

Obtén metadatos de tabla particionada con metatablas

Puedes obtener información sobre las tablas particionadas con tablas especiales llamadas metatablas. Las metatablas contienen metadatos como la lista de tablas y vistas en un conjunto de datos. Las metatablas son de solo lectura.

En este momento, no puedes usar el servicio INFORMATION_SCHEMA para obtener metadatos de tabla particionada.

Obtén metadatos de partición con metatablas

La metatabla __PARTITIONS_SUMMARY__ es una tabla especial cuyos contenidos representan metadatos de particiones en una tabla particionada por tiempo. La metatabla __PARTITIONS_SUMMARY__ es de solo lectura.

Para acceder a los metadatos sobre particiones en una tabla particionada por tiempo, usa la metatabla __PARTITIONS_SUMMARY__ en la declaración SELECT de una consulta. Tienes las siguientes opciones para ejecutar la consulta:

  • Con Cloud Console o la IU web clásica de BigQuery
  • Mediante el comando bq de la herramienta de línea de comandos de bq query
  • Con una llamada al método jobs.insert de la API y la configuración de un trabajo query
  • Usar bibliotecas cliente

Por ahora, SQL estándar no es compatible con el separador de decorador de partición ($), por lo que no puedes consultar __PARTITIONS_SUMMARY__ con SQL estándar. Una consulta de SQL heredado que usa la metatabla __PARTITIONS_SUMMARY__ se ve de la siguiente manera:

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

En el ejemplo anterior, se ilustra lo siguiente:

  • dataset es el nombre del conjunto de datos.
  • table es el nombre de la tabla particionada por tiempo.
  • column es una de las siguientes opciones:
Valor Descripción
project_id Nombre del proyecto.
dataset_id Nombre del conjunto de datos.
table_id Nombre de la tabla particionada por tiempo.
partition_id Nombre (fecha) de la partición.
creation_time El momento en que se creó la partición, expresado como la cantidad de milisegundos transcurridos desde el 1 de enero de 1970 UTC.
last_modified_time El momento en que se modificó la partición por última vez, expresado como la cantidad de milisegundos transcurridos desde el 1 de enero de 1970 UTC.

Permisos sobre la metatabla de particiones

Como mínimo, para ejecutar un trabajo de consulta que usa la metatabla __PARTITIONS_SUMMARY__, debes tener permisos bigquery.jobs.create. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.jobs.create:

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

También debes tener permisos bigquery.tables.getData. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.getData:

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

Para obtener más información sobre las funciones de IAM en BigQuery, consulta Control de acceso.

Ejemplos de metatablas de partición

La siguiente consulta recupera todos los metadatos de las particiones de una tabla particionada por rango llamada mydataset.mytable.

Console

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

bq

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

El resultado será similar al siguiente:

+----------------+------------+----------------+--------------+---------------+--------------------+
|   project_id   | dataset_id |    table_id    | partition_id | creation_time | last_modified_time |
+----------------+------------+----------------+--------------+---------------+--------------------+
| myproject      | mydataset  | mytable        | 10000        | 1517190224120 | 1517190224997      |
| myproject      | mydataset  | mytable        | 20000        | 1517190224120 | 1517190224997      |
+----------------+------------+----------------+--------------+---------------+--------------------+

La siguiente consulta muestra cuándo se modificaron por última vez las particiones en mydataset.mytable.

Console

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

bq

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

El resultado será similar al siguiente:

+--------------+--------------------+
| partition_id | last_modified_time |
+--------------+--------------------+
| 100000       |      1471632556179 |
| 20000        |      1471632538142 |
| 30000        |      1471632570463 |
+--------------+--------------------+

Para mostrar el campo last_modified_time en un formato legible, usa la función FORMAT_UTC_USEC. Por ejemplo:

Console

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

bq

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

El resultado será similar al siguiente:

+--------------+----------------------------+
| partition_id |       last_modified        |
+--------------+----------------------------+
| 10000        | 2016-08-19 18:49:30.463000 |
| 20000        | 2016-08-19 18:49:16.179000 |
| 30000        | 2016-08-19 18:48:58.142000 |
+--------------+----------------------------+

Próximos pasos