Crea y usa tablas particionadas por tiempo de transferencia

En este documento, se describe cómo crear y usar tablas particionadas por tiempo de transferencia en BigQuery. Para obtener más información sobre tablas particionadas, consulta Crea y usa tablas particionadas.

Luego de crear una tabla particionada por tiempo de transferencia, 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, incluidos cómo copiarlas, borrarlas y actualizar sus propiedades, consulta Instrucciones para administrar tablas particionadas.

Crea tablas particionadas por tiempo de transferencia

Puedes crear una tabla particionada por tiempo de transferencia en BigQuery de las siguientes maneras:

  • Mediante una declaración de DDL de CREATE TABLE con partition_expression
  • De forma manual con la IU web de BigQuery o el comando bq mk de la herramienta de línea de comandos
  • A partir de una llamada al método tables.insert de la API de manera programática
  • Desde resultados de consultas
  • Cuando cargas datos
  • Si conviertes tablas fragmentadas por fecha en tablas particionadas

Cuando creas una tabla particionada por tiempo de transferencia en BigQuery, el nombre de la tabla debe ser único por conjunto de datos. El nombre de la tabla puede contener lo siguiente:

  • Hasta 1,024 caracteres
  • Letras (mayúsculas o minúsculas), números y guiones bajos

Permisos necesarios

Para crear una tabla particionada por tiempo de transferencia, debes tener acceso de WRITER a nivel de conjunto de datos o tener asignada una función de IAM a nivel de proyecto con permisos bigquery.tables.create. Las siguientes funciones de IAM predefinidas a nivel de proyecto incluyen permisos bigquery.tables.create:

Además, debido a que la función bigquery.user tiene permisos bigquery.user, un usuario con la función bigquery.datasets.create puede crear tablas particionadas en cualquier conjunto de datos que cree. Cuando un usuario asignado a la función bigquery.user crea un conjunto de datos, se le otorga acceso de OWNER al conjunto de datos. El acceso de OWNER a un conjunto de datos le otorga al usuario control total sobre el conjunto y todas las tablas en él.

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Control de acceso. Si quieres obtener más información sobre las funciones a nivel de conjunto de datos, consulta Funciones básicas para conjuntos de datos.

Crea una tabla particionada por tiempo de transferencia con una definición de esquema

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

  • Ingresar el esquema con la IU web
  • Proporcionar el esquema intercalado con la herramienta de línea de comandos
  • Enviar un archivo de esquema JSON con la herramienta de línea de comandos
  • Proporcionar el esquema en un recurso de tabla cuando llamas 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 por tiempo de transferencia, puedes hacer lo siguiente:

  • Cargarle datos
  • Escribir resultados de consultas
  • Copiar datos

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

IU web

  1. Haz clic en el ícono de flecha hacia abajo ícono de flecha hacia abajo junto al nombre de tu conjunto de datos en el menú de navegación y haz clic en Create new table (Crear una tabla nueva).

  2. En la página Create Table (Crear tabla), en la sección Source Data (Datos fuente), haz clic en Create empty table (Crear una tabla vacía).

  3. En la página Create Table, en la sección Destination Table (Tabla de destino), haz lo siguiente:

    • Para Table name (Nombre de la tabla), elige el conjunto de datos apropiado y, en el campo de nombre, ingresa el nombre de la tabla que creas.
    • Verifica que Table type (Tipo de tabla) esté configurado como Native table (Tabla nativa).
  4. En la sección Esquema, ingresa de forma manual la definición de esquema.

    • Para ingresar la información del esquema de forma manual, haz lo siguiente:

      • Haz clic en Edit as text (Editar como texto) y luego ingresa el esquema de la tabla como un arreglo de JSON:

        Agregar un esquema como arreglo de JSON

      • Usa Add Field (Agregar campo) para ingresar el esquema:

        Agregar esquema con agregar campos

  5. En la sección Options (Opciones), haz lo siguiente:

  6. Haz clic en Create Table.

Una vez que se crea la tabla, puedes actualizar el vencimiento, la descripción y las etiquetas de la tabla particionada. No puedes agregar un vencimiento de partición con la IU web de BigQuery luego de crear la tabla.

Línea de comandos

Usa el comando mk con la marca --table (o el acceso directo -t) y la marca --time_partitioning_type=DAY. Por ahora, DAY es el único valor compatible con --time_partitioning_type. Puedes proveer la definición del esquema de la tabla de forma intercalada o con un archivo de esquema JSON. Los parámetros opcionales incluyen --expiration, --description, --time_partitioning_expiration, --destination_kms_key y --label. Si creas una tabla en un proyecto que no es el predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: [PROJECT_ID]:[DATASET].

--destination_kms_key no se muestra aquí. Para obtener más información sobre el uso de esta marca, consulta llaves de encriptación administradas por el cliente.

Ingresa el siguiente comando para crear una tabla particionada por tiempo de transferencia vacía con una definición de esquema:

bq mk --table --expiration [INTEGER1] --time_partitioning_type=DAY --time_partitioning_expiration [INTEGER2] --description "[DESCRIPTION]" --label [KEY:VALUE, KEY:VALUE] [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]

Donde:

  • [INTEGER1] es la duración predeterminada (en segundos) para la tabla. El valor mínimo es 3,600 segundos (una hora). La fecha de vencimiento se evalúa según la fecha actual más el valor del número entero. Si configuras la fecha de vencimiento cuando creas una tabla particionada, se ignora la configuración predeterminada del vencimiento de la tabla para el conjunto de datos. Si configuras este valor, la tabla y todas las particiones se borran después del período especificado.
  • [INTEGER2] es la duración predeterminada (en segundos) para las particiones de la tabla. No hay un valor mínimo. La fecha de vencimiento se evalúa según la fecha de la partición más el número entero. El vencimiento de la partición es independiente del de la tabla, pero no lo reemplaza. Si estableces un vencimiento de partición que supera al de la tabla, el vencimiento de la tabla prevalece.
  • [DESCRIPTION] es una descripción de la tabla en cuotas.
  • [KEY:VALUE] es el par clave-valor que representa una etiqueta. Puedes ingresar múltiples etiquetas en una lista separada por comas.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es un conjunto de datos en tu proyecto.
  • [TABLE] es el nombre de la tabla de partición por tiempo que creas.
  • [SCHEMA] es una definición de esquema intercalado en el formato [FIELD]:[DATA_TYPE],[FIELD]:[DATA_TYPE] o la ruta al archivo de esquema JSON en tu máquina local.

Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo de RECORD (STRUCT) o una descripción de la columna, ni especificar el modo de esta. Según la configuración predeterminada, todos los modos son NULLABLE. Para incluir descripciones, modos y tipos de RECORD, proporciona un archivo de esquema JSON.

Ejemplos:

Ingresa el siguiente comando para crear una tabla particionada por tiempo de transferencia llamada mytable en mydataset en tu proyecto predeterminado. El vencimiento de la partición está establecido en 259,200 segundos (3 días), el de la tabla en 2,592,000 (1 mes de 30 días), la descripción está establecida en This is my time-partitioned table y la etiqueta en organization:development. El comando usa el acceso directo -t en lugar de --table. El esquema está especificado de forma intercalada como: qtr:STRING,sales:FLOAT,year:STRING.

bq mk -t --expiration 2592000 --time_partitioning_type=DAY --time_partitioning_expiration 259200 --description "This is my time-partitioned table" --label organization:development mydataset.mytable qtr:STRING,sales:FLOAT,year:STRING

Ingresa el siguiente comando para crear una tabla particionada por tiempo de transferencia llamada mytable en myotherproject, no en tu proyecto predeterminado. El vencimiento de la partición está establecido en 259,200 segundos (3 días), la descripción está establecida en This is my time-partitioned table y la etiqueta en organization:development. El comando usa el acceso directo -t en lugar de --table. Este comando no especifica el vencimiento de la tabla. Si el conjunto de datos tiene un vencimiento de tabla predeterminado, se aplica. Si el conjunto de datos no tiene un vencimiento de tabla predeterminado, la tabla no expirará pero las particiones lo harán luego de 3 días. La ruta al archivo de esquema es /tmp/myschema.json.

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

Luego de que se crea la tabla, puedes actualizar el vencimiento de la tabla, el vencimiento de las particiones, la descripción y las etiquetas de la tabla particionada por tiempo de transferencia.

API

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

Crea una tabla particionada por tiempo de transferencia a partir del resultado de una consulta

Para crear una tabla particionada a partir del resultado de una consulta, escribe los resultados en una tabla de destino nueva. Puedes crear una tabla particionada nueva si consultas una tabla particionada o una no particionada. No puedes cambiar una tabla existente a una tabla particionada con los resultados de consulta.

Para obtener más información sobre consultas a tablas particionadas por tiempo, lee Consulta tablas particionadas.

IU web

No puedes especificar opciones de partición para una tabla de destino cuando consultas datos con la IU web de BigQuery.

CLI

Ingresa el comando bq query, especifica la marca --destination_table para crear una tabla permanente con base en los resultados de la consulta y especifica la marca --time_partitioning_type=DAY para crear una tabla de destino particionada por tiempo de transferencia. Por ahora, DAY es el único valor compatible con --time_partitioning_type.

Especifica la marca use_legacy_sql=false para usar la sintaxis de SQL estándar. Para escribir los resultados de la consulta en una tabla que no esta en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el siguiente formato: [PROJECT_ID]:[DATASET].

Proporciona la marca --location y configura el valor en tu ubicación.

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

    bq --location=[LOCATION] query --destination_table [PROJECT_ID]:[DATASET].[TABLE] --time_partitioning_type=DAY --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 región de Tokio, puedes configurar el valor de la marca en 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 nueva tabla particionada por tiempo.
  • [TABLE] es el nombre de la tabla particionada por tiempo que creas a partir de los resultados de la consulta.
  • [QUERY] es una consulta en la sintaxis de SQL estándar.

Ejemplos:

Ingresa el siguiente comando para escribir resultados de consultas en una tabla de destino particionada por tiempo de transferencia llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. La consulta obtiene datos de una tabla no particionada: el conjunto de datos públicos Datos de nombres de EE.UU.

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

Ingresa el siguiente comando para escribir resultados de consultas en una tabla de destino particionada por tiempo de transferencia llamada mytable en mydataset. El conjunto de datos se encuentra en myotherproject, no en tu proyecto predeterminado. La consulta obtiene datos de una tabla no particionada: el conjunto de datos públicos Datos de nombres de EE.UU.

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

API

Para guardar los resultados de la consulta en una tabla particionada por tiempo de transferencia permanente, llama al método jobs.insert, establece un trabajo de query y luego incluye un valor para las propiedades configuration.query.destinationTable y timePartitioning.

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

Crea una tabla particionada por tiempo de transferencia cuando cargas datos

Puedes crear una tabla particionada por tiempo de transferencia si especificas las opciones de partición cuando cargas datos en una tabla nueva. No necesitas crear una tabla particionada vacía antes de cargar datos en ella. Puedes crear la 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. A fin de realizar ajustes a las zonas horarias, puedes usar un decorador de particiones para cargar datos en una partición según tu zona horaria de preferencia. Por ejemplo, si te encuentras en la hora estándar del Pacífico (PST), carga todos los datos que se generen el 1 de mayo de 2016 PST en la partición correspondiente a esa fecha con el decorador de particiones adecuado:

[TABLE_NAME]$20160501

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

Convierte tablas fragmentadas por fecha en tablas particionadas por tiempo de transferencia

Si tienes tablas anteriores fragmentadas por fecha, puedes convertir el conjunto entero de tablas relacionadas en una sola tabla particionada por tiempo de transferencia con el comando partition en la herramienta de línea de comandos de bq. La tabla fragmentada por fecha debe respetar la siguiente convención para el nombre: [TABLE]_YYYYMMDD. Por ejemplo, mytable_20160101, …, mytable_20160331.

Los parámetros opcionales incluyen --time_partitioning_expiration y --time_partitioning_type. Debido a que --time_partitioning_type=DAY es el único valor admitido por ahora, este parámetro es opcional. Si tus tablas fuente o tu tabla de destino se encuentran en un proyecto que no es el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos con el siguiente formato: [PROJECT_ID]:[DATASET].

Proporciona la marca --location y configura el valor en tu ubicación.

Ingresa el siguiente comando para convertir una serie de tablas fragmentadas por fecha en una sola tabla particionada por tiempo de transferencia:

bq --location=[LOCATION] partition --time_partitioning_type=DAY --time_partitioning_expiration [INTEGER] [PROJECT_ID]:[DATASET].[SOURCE_TABLE]_ [PROJECT_ID]:[DATASET].[DESTINATION_TABLE]

Donde:

  • [LOCATION] es el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, configura el valor de la marca en asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • [INTEGER] es la duración predeterminada (en segundos) para las particiones de la tabla. No hay un valor mínimo. La fecha de vencimiento se evalúa según la fecha de la partición más el número entero. El vencimiento de la partición es independiente del de la tabla, pero no lo reemplaza. Si estableces un vencimiento de partición que supera al de la tabla, el vencimiento de la tabla prevalece.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es un conjunto de datos en tu proyecto.
  • [SOURCE_TABLE]_ es el prefijo de tu tabla fragmentada por fecha.
  • [DESTINATION_TABLE] es el nombre de la tabla particionada que creas.

Ejemplos:

Ingresa el siguiente comando para crear una tabla particionada por tiempo de transferencia llamada mytable_partitioned en mydataset en tu proyecto predeterminado. El vencimiento de la partición está configurado a los 259,200 segundos (3 días). Las tablas fuente fragmentadas usan el prefijo sourcetable_. Las tablas fuente también se encuentran en tu proyecto predeterminado. mydataset se creó en la ubicación multirregión US.

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

Cuando ejecutas el comando, se crea un trabajo de copia que genera particiones de tablas fragmentadas. Por ejemplo, si las tablas fragmentadas por fecha son sourcetable_20180126 y sourcetable_20180127, el trabajo de copia crea las siguientes particiones: mydataset.mytable_partitioned$20180126 y mydataset.mytable_partitioned$20180127.

Ingresa el siguiente comando para crear una tabla particionada por tiempo de transferencia llamada mytable_partitioned en mydataset. mydataset se encuentra en myotherproject, no en tu proyecto predeterminado. El vencimiento de la partición está configurado a los 86,400 segundos (1 día). Las tablas fuente fragmentadas usan el prefijo sourcetable_. Las tablas fuente se encuentran en tu proyecto predeterminado. mydataset se creó en la ubicación multirregión US.

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

Ingresa el siguiente comando para crear una tabla particionada por tiempo de transferencia llamada mytable_partitioned en mydataset en tu proyecto predeterminado. mydataset se creó en la región asia-northeast1. El vencimiento de la partición está configurado a los 259,200 segundos (3 días). Las tablas fuente fragmentadas usan el prefijo sourcetable_. Las tablas fuente también se encuentran en tu proyecto predeterminado.

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

Controla el acceso a tablas particionadas por tiempo

No puedes asignar controles de acceso a tablas o particiones de forma directa. Puedes controlar el acceso a tablas con la configuración de los controles de acceso a nivel de proyecto o de conjunto de datos.

Los controles de acceso a nivel de conjunto de datos especifican las operaciones que los usuarios, grupos y cuentas de servicio pueden realizar en las tablas de ese conjunto de datos específico. Si solo asignas permisos a nivel de conjunto de datos, también debes asignar una función básica o predefinida a nivel de proyecto que proporcione acceso al proyecto, por ejemplo, bigquery.user.

En lugar de otorgar el acceso a conjuntos de datos individuales, puedes asignar funciones de IAM predefinidas a nivel de proyecto que otorguen permisos para todos los datos de tablas en todos los conjuntos de datos de un proyecto.

También puedes crear funciones de IAM personalizadas. Si creas una función personalizada, los permisos que otorgas dependen de las operaciones de tabla que quieres que el usuario, grupo o cuenta de servicio puedan realizar.

Para obtener más información acerca de las funciones y permisos, consulta los siguientes documentos:

Usa tablas particionadas por tiempo de transferencia

Obtén información sobre tablas particionadas por tiempo de transferencia

Puedes obtener información sobre tablas con la IU web de BigQuery, el comando bq show de la CLI o una llamada al método tables.get de la API.

Permisos necesarios

Para obtener información sobre tablas, debes tener asignada la función de READER en el conjunto de datos o debes tener asignada una función de IAM a nivel de proyecto que incluya permisos bigquery.tables.get. Si tienes permisos bigquery.tables.get a nivel de proyecto, puedes obtener información sobre todas las tablas en el proyecto. Todas las funciones de IAM predefinidas a nivel de proyecto incluyen los permisos bigquery.tables.get excepto bigquery.jobUser y bigquery.user.

Además, un usuario con la función bigquery.user tiene permisos bigquery.datasets.create. Esto le permite a un usuario con la función bigquery.user obtener información sobre tablas en cualquier conjunto de datos que cree. Cuando un usuario asignado a la función bigquery.user crea un conjunto de datos, se le otorga acceso de OWNER al conjunto de datos. El acceso de OWNER a un conjunto de datos le otorga al usuario control total sobre el conjunto y todas las tablas en él.

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Control de acceso. Si quieres obtener más información sobre las funciones a nivel de conjunto de datos, consulta Funciones básicas para conjuntos de datos.

Obtén información sobre tablas particionadas por tiempo de transferencia

Para obtener información sobre una tabla particionada por tiempo de transferencia, haz lo siguiente:

IU web

  1. En el panel de navegación, haz clic en el ícono de flecha hacia abajo ícono de flecha hacia abajo que se encuentra a la izquierda de tu conjunto de datos para expandirlo o haz doble clic en su nombre. Esto muestra las tablas y vistas en el conjunto de datos.

  2. Haz clic en el nombre de la tabla.

  3. Haz clic en Details (Detalles). La página Table Details (Detalles de la tabla) muestra la descripción y la información de la tabla.

    Detalles de la tabla particionada

  4. Haz clic en la pestaña Schema (Esquema) para ver la definición del esquema de la tabla. Observa la pseudocolumna adicional _PARTITIONTIME que contiene la marca de tiempo basada en la fecha para los datos cargados en la tabla.

    Esquema de tabla particionada

Línea de comandos

Ejecuta 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 puede usarse para controlar el resultado.

Si obtienes información sobre una tabla en un proyecto que no es el predeterminado, agrega el ID del proyecto al conjunto de datos con el siguiente formato: [PROJECT_ID]:[DATASET].

bq show --schema --format=prettyjson [PROJECT_ID]:[DATASET].[TABLE]

Donde:

  • [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 se encuentra 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 se encuentra en myotherproject, no en tu proyecto predeterminado.

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

Ingresa el siguiente comando para mostrar solo la información del esquema de mytable en mydataset. mydataset se encuentra en myotherproject, no en tu proyecto predeterminado.

Cuando muestras la información del esquema de una tabla particionada por tiempo de transmisión, no se muestra la pseudocolumna_PARTITIONTIME.

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

API

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

Obtén una lista de las tablas particionadas por tiempo de transferencia en un conjunto de datos

Puedes obtener una lista de las tablas en un conjunto de datos (incluidas las tablas particionadas) con la IU web de BigQuery, el comando bq ls de la CLI o una llamada al método tables.list de la API.

Permisos necesarios

Para ver una lista de las tablas en un conjunto de datos, debes tener asignada la función de READER en el conjunto de datos o tener una función de IAM a nivel de proyecto con permisos bigquery.tables.list. Si tienes permisos bigquery.tables.list a nivel de proyecto, puedes ver una lista de las tablas en cualquier conjunto de datos en el proyecto. Todas las funciones de IAM predefinidas a nivel de proyecto incluyen permisos bigquery.tables.list, excepto bigquery.jobUser.

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Control de acceso. Si quieres obtener más información sobre las funciones a nivel de conjunto de datos, consulta Funciones básicas para conjuntos de datos.

Obtén una lista de tablas particionadas

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

IU web

  1. En la IU web, en el panel de navegación, haz clic en el ícono de flecha hacia abajo ícono de flecha hacia abajo que se encuentra a la izquierda de tu conjunto de datos para expandirlo o haz doble clic en su nombre. Esto muestra las tablas y vistas en el conjunto de datos.

  2. Desplázate por la lista para ver las tablas en el conjunto de datos. Las tablas y las vistas están identificadas con íconos diferentes.

    Ver tablas

CLI

Ejecuta el comando bq ls. La marca --format puede usarse para controlar el resultado. Si quieres obtener la lista de tablas en un proyecto que no es el predeterminado, agrega el ID del proyecto al conjunto de datos con el siguiente formato: [PROJECT_ID]:[DATASET].

bq ls --format=pretty [PROJECT_ID]:[DATASET]

Donde:

  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos.

Cuando ejecutas el comando, el campo Type muestra TABLE o VIEW. Para las tablas particionadas por tiempo de transferencia, el campo Time Partitioning muestra DAY y el vencimiento en milisegundos (si existe).

Por ejemplo:

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

Ejemplos:

Ingresa el siguiente comando para crear una lista de las tablas en el conjunto de datos mydataset en tu proyecto predeterminado.

bq ls --format=pretty mydataset

Ingresa el siguiente comando para crear una lista de las tablas en el conjunto de datos mydataset en myotherproject.

bq ls --format=pretty myotherproject:mydataset

API

Para crear una lista de tablas con la API, llama al método tables.list.

Crea una lista de particiones en tablas particionadas por tiempo de transferencia

Puedes crear una lista de las particiones en una tabla particionada por tiempo de transferencia si consultas la pseudocolumna _PARTITIONTIME (en SQL estándar) o la metatabla __PARTITIONS_SUMMARY__ (en SQL heredado).

Puedes ejecutar la consulta en la IU web de BigQuery con el comando bq query o si llamas al método jobs.insert y configuras un trabajo de query.

Permisos necesarios

Para ejecutar un trabajo de consulta que usa la metatabla __PARTITIONS_SUMMARY__ o la pseudocolumna _PARTITIONTIME, debes tener permisos bigquery.jobs.create. Las siguientes funciones de IAM predefinidas a nivel de proyecto incluyen los permisos bigquery.jobs.create:

También debes tener asignada la función de READER a nivel de conjunto de datos o una función de IAM a nivel de proyecto con permisos bigquery.tables.getData. Todas las funciones de IAM predefinidas a nivel de proyecto incluyen los permisos bigquery.tables.getData, excepto bigquery.user, bigquery.jobUser y bigquery.metadataViewer.

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Control de acceso. Si quieres obtener más información sobre las funciones a nivel de conjunto de datos, consulta Funciones básicas para conjuntos de datos.

Crea una lista de particiones en una tabla particionada por tiempo de transferencia

Puedes crear una lista de particiones en una tabla particionada por tiempo de transferencia con SQL estándar (método preferido) o SQL heredado de la siguiente forma:

SQL estándar:

IU web

  1. Dirígete a la IU web de BigQuery.

    Ir a la IU web de BigQuery

  2. Haz clic en el botón Compose query (Redactar consulta).

  3. Ingresa el siguiente texto en el cuadro de New Query (Nueva consulta) para consultar la pseudocolumna _PARTITIONTIME de una tabla:runque

    #standardSQL
    SELECT
      _PARTITIONTIME as pt
    FROM
      `[DATASET].[TABLE]`
    GROUP BY 1
    

    Donde:

    • [DATASET] es el conjunto de datos que contiene la tabla.
    • [TABLE] es el nombre de la tabla.
  4. Haz clic en Show options (Mostrar opciones).

  5. (Opcional) Para Processing Location (Ubicación de procesamiento), haz clic en Unspecified (Sin especificar) y elige la ubicación de tus datos.

  6. Haz clic en Run query (Ejecutar consulta).

CLI

Ingresa la siguiente consulta con el comando bq query:

bq --location=[LOCATION] query --use_legacy_sql=false '
SELECT
  _PARTITIONTIME as pt
FROM
  `[DATASET].[TABLE]`
GROUP BY 1'

Where:

  + `[LOCATION]` is the name of your location. The `--location` flag is
    optional. For example, if you are using BigQuery in
    the Tokyo region, you can set the flag's value to `asia-northeast1`.
    You can set a default value for the location using the
    [.bigqueryrc file](/bigquery/docs/bq-command-line-tool#setting_default_values_for_command-line_flags).
  + `[DATASET]` is the dataset that contains the table.
  + `[TABLE]` is the name of the table.

API

Llama al método jobs.insert y configura un trabajo de query que consulta la pseudocolumna _PARTITIONTIME de la tabla.

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

SQL heredado:

IU web

  1. Dirígete a la IU web de BigQuery.

    Ir a la IU web de BigQuery

  2. Haz clic en el botón Compose query.

  3. Ingresa el siguiente texto en el cuadro de New Query para consultar la metatabla __PARTITIONS_SUMMARY__ de una tabla:

    #legacySQL
    SELECT
       partition_id
     FROM
       [[DATASET].[TABLE]$__PARTITIONS_SUMMARY__]
    

    Donde:

    • [DATASET] es el conjunto de datos que contiene la tabla.
    • [TABLE] es el nombre de la tabla.
  4. Haz clic en Show options.

  5. (Opcional) Para Processing Location, haz clic en Unspecified y elige la ubicación de tus datos.

  6. Haz clic en Run query.

CLI

Ingresa la siguiente consulta con el comando bq query:

bq --location=[LOCATION] query --use_legacy_sql=true '
SELECT
   partition_id
 FROM
   [[DATASET].[TABLE]$__PARTITIONS_SUMMARY__]'

Where:

  + `[LOCATION]` is the name of your location. The `--location` flag is
    optional. For example, if you are using BigQuery in
    the Tokyo region, you can set the flag's value to `asia-northeast1`.
    You can set a default value for the location using the
    [.bigqueryrc file](/bigquery/docs/bq-command-line-tool#setting_default_values_for_command-line_flags).
  + `[DATASET]` is the dataset that contains the table.
  + `[TABLE]` is the name of the table.

API

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

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

Obtén los metadatos de la tabla con metatablas

El proceso para obtener metadatos de una tabla particionada por tiempo de transferencia es igual al proceso para obtener datos de una tabla estándar. Si quieres obtener más información, consulta Obtén metadatos de una tabla mediante metatablas.

Cuando consultas la metatabla __TABLES_SUMMARY__, se muestra una lista de todas las tablas. No hay opción de type para distinguir las tablas particionadas de las no particionadas.

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 solo de 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. Puedes ejecutar la consulta con la consola, la IU web de BigQuery clásica, el comando bq query de la herramienta de línea de comandos o si llamas al método jobs.insert de la API y configuras un trabajo de consulta.

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

    SELECT [COLUMN] FROM [[DATASET].[TABLE]$__PARTITIONS_SUMMARY__]

Donde:

  • [DATASET] es el nombre de tu 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, en milisegundos, desde el 1 de enero de 1970 UTC.
last_modified_time El momento en que se modificó la partición por última vez, en milisegundos, desde el 1 de enero de 1970 UTC.

Permisos de metatablas de partición

Para ejecutar un trabajo de consulta que usa la metatabla __PARTITIONS_SUMMARY__, debes tener permisos bigquery.jobs.create. Las siguientes funciones de IAM predefinidas a nivel de proyecto incluyen los permisos bigquery.jobs.create:

También debes tener asignada la función de READER a nivel de conjunto de datos o una función de IAM a nivel de proyecto con permisos bigquery.tables.getData. Todas las funciones de IAM predefinidas a nivel de proyecto incluyen los permisos bigquery.tables.getData, excepto bigquery.user, bigquery.jobUser y bigquery.metadataViewer.

Ejemplos de metatablas de partición

La siguiente consulta obtiene todos los metadatos de partición de una tabla de partición por tiempo llamada mydataset.mytable.

IU clásica

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

Línea de comandos

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

El resultado se ve de la siguiente manera:

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

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

IU clásica

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

Línea de comandos

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

El resultado se ve de la siguiente manera:

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

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

IU clásica

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

Línea de comandos

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 se ve de la siguiente manera:

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

Ejemplo: crea una tabla particionada por tiempo de transferencia a partir de los resultados de consultas

En este ejemplo, creas una tabla particionada por tiempo de transferencia con la herramienta de línea de comandos y agregas datos a las tres particiones con los resultados de las consultas. La tabla contendrá datos del tiempo, particionados por fecha, de los primeros tres días de 2016.

En este ejemplo, se consulta el conjunto de datos del tiempo de NOAA GSOD de las temperaturas de los primeros tres días de 2016 y se escriben los resultados en una tabla particionada. En este ejemplo, se usa la marca --location=US porque se consulta un conjunto de datos públicos. Los conjuntos de datos públicos de BigQuery se almacenan en la ubicación multirregión de EE.UU. Debido a que los conjuntos de datos públicos se almacenan en EE.UU., no puedes escribir resultados de consultas a datos públicos en una tabla de otra región ni unir tablas en conjuntos de datos públicos con tablas en otra región.

Paso 1. Crea una tabla particionada por tiempo de transferencia vacía llamada temps en un conjunto de datos llamado mydataset. No es necesario especificar un esquema para la tabla. El esquema de los resultados de consulta se usa como la definición de esquema para la tabla.

bq mk --time_partitioning_type=DAY mydataset.temps

Para ver las opciones de configuración, usa el comando bq show:

bq show --format=prettyjson mydataset.temps

Busca la entrada timePartitioning en el resultado del comando bq show:

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

Paso 2. Consulta el conjunto de datos del clima de NOAA GSOD para obtener las temperaturas de los primeros tres días de 2016 y escribe los resultados en las particiones correspondientes en la tabla temps. Las siguientes consultas usan la opción --destination_table y la sintaxis de SQL estándar para escribir 100 filas de resultados de consultas en una partición.

  1. Ejecuta la siguiente consulta para escribir las temperaturas del 1 de enero de 2016 en la partición mydataset.temps$20160101:

    bq --location=US query --use_legacy_sql=false \
    --destination_table 'mydataset.temps$20160101' \
    'SELECT stn,temp from `bigquery-public-data.noaa_gsod.gsod2016` WHERE mo="01" AND da="01" limit 100'
    
  2. Ejecuta la siguiente consulta para escribir las temperaturas del 2 de enero de 2016 en la partición mydataset.temps$20160102:

    bq --location=US query --use_legacy_sql=false \
    --destination_table 'mydataset.temps$20160102' \
    'SELECT stn,temp from `bigquery-public-data.noaa_gsod.gsod2016` WHERE mo="01" AND da="02" limit 100'
    
  3. Ejecuta la siguiente consulta para escribir las temperaturas del 3 de enero de 2016 en la partición mydataset.temps$20160103.

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

Paso 3. Confirma que tienes 300 filas en tu tabla con el comando bq show.

bq show mydataset.temps

Los resultados muestran el esquema y el total de filas.

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

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.