Crea y usa tablas agrupadas

En este documento se describe el proceso para crear y usar tablas agrupadas en BigQuery. Para obtener una descripción general de la compatibilidad con tablas agrupadas en BigQuery, consulta Introducción a las tablas agrupadas.

Limitaciones

Las tablas agrupadas en BigQuery están sujetas a las limitaciones siguientes:

  • Por ahora, el agrupamiento en clústeres es compatible solo con tablas particionadas.
  • Solo se admite SQL estándar para consultar las tablas agrupadas y escribir los resultados de consultas en tablas agrupadas.
  • Solo puedes especificar columnas de agrupamiento en clústeres cuando se crea una tabla.
  • Después de crear una tabla agrupada, las columnas de agrupamiento en clústeres no se pueden modificar.
  • Las columnas de agrupamiento en clústeres deben ser de nivel superior, no se pueden repetir y deben ser de uno de los siguientes tipos: INT64, STRING, DATE, TIMESTAMP, BOOL, NUMERIC o GEOGRAPHY. Para obtener más información sobre los tipos de datos, consulta Tipos de datos de SQL estándar.
  • Puedes especificar hasta cuatro columnas de agrupamiento en clústeres.

Crea tablas agrupadas

Por ahora, solo puedes agrupar una tabla particionada. Esto incluye las tablas particionadas por tiempo de transferencia y las tablas particionadas por una columna TIMESTAMP o DATE.

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

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:

  • Contener 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:

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

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

Las siguientes funciones de Cloud IAM predefinidas incluyen los permisos bigquery.tables.create y bigquery.tables.updateData:

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

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

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

Además, si un usuario tiene permisos bigquery.datasets.create, cuando cree un conjunto de datos se le otorgará el permiso bigquery.dataOwner para acceder a este. El acceso bigquery.dataOwner permite al usuario crear y actualizar tablas en el conjunto de datos.

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

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

Cuando creas una tabla en BigQuery, especificas las columnas de agrupamiento en clústeres. Después de crear la tabla, no puedes modificar estas columnas. Por ahora, solo puedes especificar las columnas de agrupamiento en clústeres para una tabla particionada.

Las columnas de agrupamiento en clústeres deben ser de nivel superior, no se pueden repetir y deben ser de uno de los tipos de datos simples siguientes: INTEGER, STRING, DATE, TIMESTAMP, BOOLEAN, NUMERIC o GEOGRAPHY.

Puedes especificar hasta cuatro columnas de agrupamiento en clústeres. Cuando especificas varias columnas, el orden de las columnas determina el orden de los datos. Por ejemplo, si la tabla está agrupada por las columnas a, b y c, los datos se ordenan en el mismo orden; primero por la columna a, luego por la b y, por último, por la c. Se recomienda que la columna que se agrega o se filtra con más frecuencia aparezca primero.

El orden de las columnas de agrupamiento en clústeres también afecta el rendimiento y el precio de la consulta. Para obtener más información sobre las recomendaciones de consultas de tablas agrupadas, lee Cómo consultar tablas agrupadas.

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

Console

  1. Abre la IU web de BigQuery en GCP Console.
    Ir a GCP Console

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

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

    Botón Crear tabla

  4. En la página Crear tabla, en la sección Fuente, en Crear tabla desde, selecciona Tabla vacía.

    Opción Crear tabla desde

  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é configurado como 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. Para la Configuración de partición y agrupamiento en clústeres, haz clic en Sin particionar, selecciona Particionar por campo y elige la columna DATE o TIMESTAMP. Esta opción no está disponible si el esquema no contiene una columna DATE o TIMESTAMP.

    Para crear una tabla particionada por tiempo de transferencia, haz clic en Sin particionar y selecciona Partición por tiempo de transferencia.

  8. 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). La solicitud de un filtro de partición puede reducir el costo y mejorar el rendimiento. Para obtener más información, visita Consulta tablas particionadas.

  9. Para Orden de agrupamiento en clústeres, ingresa entre uno y cuatro nombres de columna separados por comas.

  10. Haz clic en Opciones avanzadas y para Encriptación, haz clic en Clave administrada por el cliente a fin de usar una Clave de Cloud Key Management Service (opcional). Si dejas establecida la configuración Clave administrada por Google, BigQuery encripta los datos en reposo.

  11. Haz clic en Crear tabla.

IU clásica

  1. Ve a la IU web clásica de BigQuery.

    Ir a la IU web clásica de BigQuery

  2. 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, luego, en Crear tabla nueva.

  3. En la página Crear tabla, en la sección Datos de origen, haz clic en Crear tabla vacía.

  4. En la página Crear tabla, en la sección Tabla de destino, realiza lo siguiente:

    • Para el Nombre de la tabla, elige el conjunto de datos apropiado y, en el campo correspondiente, ingresa el nombre de la tabla que creas en ese momento.
    • Verifica que Tipo de tabla esté configurado como Tabla nativa.
  5. En la sección Esquema, ingresa la definición de esquema de forma manual.

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

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

      • Usa Argegar campo para ingresar el esquema.

  6. En la sección Opciones:

    • Para Tipo de partición, haz clic en Ninguna y elige Día.
    • Para Campo de partición, elige uno de los siguientes:
      • Elige timestamp para crear una tabla particionada por una columna de DATE o TIMESTAMP.
      • Elige _PARTITIONTIME para crear una tabla particionada por tiempo de transferencia.
    • Para Columnas de agrupamiento en clústeres, ingresa entre uno y cuatro nombres de campo.
    • Para Encriptación de destino, deja la opción Default. Esta propiedad es para claves de encriptación administradas por clientes. De manera predeterminada, BigQuery encripta contenido de cliente almacenado en reposo.

      Detalles de la tabla particionada

  7. Haz clic en Crear tabla.

Después de crear la tabla, puedes actualizar el vencimiento de tabla, la descripción y las etiquetas de la tabla agrupada en clústeres. No puedes agregar un vencimiento de partición con la IU web de BigQuery luego de crear la tabla.

CLI

Usa el comando mk con las siguientes marcas:

  • --table (o el acceso directo -t).
  • --schema &mdash: puedes suministrar la definición del esquema de la tabla intercalada o a través de un archivo de esquema JSON.
  • --time_partitioning_type (para tablas particionadas en tiempo de transferencia) o --time_partitioning_field (para tablas particionadas). Por ahora, DAY es el único valor compatible para --time_partitioning_type.
  • --clustering_fields para especificar hasta cuatro columnas de agrupamiento en clústeres.

Los parámetros opcionales incluyen --expiration, --description, --time_partitioning_expiration, --destination_kms_key y --label.

Si creas una tabla en otro proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el formato siguiente: 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 comando siguiente para crear una tabla agrupada vacía con una definición de esquema:

bq mk \
--table \
--expiration integer1 \
--schema schema \
--time_partitioning_type=DAY \
--time_partitioning_field partition_column \
--clustering_fields cluster_columns \
--time_partitioning_expiration integer2 \
--description "description" \
--label key:value,key:value \
project_id:dataset.table

En el que:

  • integer1 es la duración predeterminada (en segundos) de la tabla. El valor mínimo es 3,600 segundos (una hora). El tiempo de caducidad se evalúa según la hora UTC actual más el valor del número entero. Si configuras el tiempo de vencimiento de la tabla cuando creas una tabla particionada por el tiempo, se ignora la configuración de vencimiento de la tabla predeterminada del conjunto de datos. Si configuras este valor, la tabla y todas las particiones se borran después del lapso especificado.
  • schema es una definición del esquema intercalado en el formato column:data_type,column:data_type o la ruta al archivo del esquema JSON de tu máquina local.
  • partition_column es el nombre de la columna TIMESTAMP o DATE que se usa para crear una tabla particionada. Si creas, una tabla particionada, no necesitas especificar la marca --time_partitioning_type=DAY.
  • cluster_columns es una lista separada por comas de hasta cuatro columnas de agrupamiento en clústeres.
  • integer2 es la duración predeterminada (en segundos) de las particiones de la tabla. No hay valor mínimo. El tiempo de vencimiento se evalúa según la fecha de la partición más el valor de número entero. El vencimiento de la partición es independiente del vencimiento de la tabla, pero no lo anula. Si configuras un vencimiento de partición que suceda después del vencimiento de la tabla, prevalece el vencimiento de la tabla.
  • description es una descripción de la tabla entre comillas.
  • key:value es el par clave-valor que representa una etiqueta. Puedes ingresar múltiples etiquetas mediante una lista separada por comas.
  • project_id es el ID del proyecto.
  • dataset es el conjunto de datos en tu proyecto.
  • table es el nombre de la tabla particionada que creaste.

Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo RECORD STRUCT ni una descripción de la columna, y no puedes especificar el modo de la columna. Todos los modos son NULLABLE de forma predeterminada. Para incluir descripciones, modos y tipos de RECORD, suministra un archivo de esquema JSON en su lugar.

Ejemplos:

Ingresa el comando siguiente para crear una tabla agrupada llamada myclusteredtable en mydataset en tu proyecto predeterminado. La tabla es una tabla particionada (particionada por una columna TIMESTAMP). El vencimiento de la partición está configurado en 86,400 segundos (1 día), el vencimiento de la tabla está configurado en 2,592,000 (1 mes de 30 días), la descripción está configurada como This is my clustered table y la etiqueta está configurada como organization:development. El comando usa el acceso directo -t en lugar de --table.

El esquema está especificado de forma intercalada como: timestamp:timestamp,customer_id:string,transaction_amount:float. El campo de agrupamiento en clústeres especificado customer_id se usa para agrupar las particiones.

bq mk -t \
--expiration 2592000 \
--schema 'timestamp:timestamp,customer_id:string,transaction_amount:float' \
--time_partitioning_field timestamp \
--clustering_fields customer_id \
--time_partitioning_expiration 86400  \
--description "This is my clustered table" \
--label org:dev \
mydataset.myclusteredtable

Ingresa el comando siguiente para crear una tabla agrupada llamada myclusteredtable en myotherproject y no en tu proyecto predeterminado. La tabla es una tabla particionada en tiempo de transferencia. El vencimiento de la partición está configurado en 259,200 segundos (3 días), la descripción está configurada en This is my partitioned table, y la etiqueta está configurada en organization:development. El comando usa el acceso directo -t en lugar de --table. El comando no especifica un vencimiento de tabla. Si el conjunto de datos tiene un vencimiento de tabla predeterminado, se aplica. Si no lo tiene, la tabla no se vencerá nunca, pero las particiones se vencerán en 3 días.

El esquema se especifica en un archivo JSON local: /tmp/myschema.json. El campo customer_id se usa para agrupar las particiones.

bq mk -t \
--expiration 2592000 \
--schema /tmp/myschema.json \
--time_partitioning_type=DAY \
--clustering_fields=customer_id \
--time_partitioning_expiration 86400  \
--description "This is my partitioned table" \
--label org:dev \
myotherproject:mydataset.myclusteredtable

Una vez creada la tabla, puedes actualizar el vencimiento de tabla, el vencimiento de 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 especifique las propiedades timePartitioning, clustering.fields y schema.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go incluidas en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la Documentación de referencia de la API de Go de BigQuery.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
sampleSchema := bigquery.Schema{
	{Name: "timestamp", Type: bigquery.TimestampFieldType},
	{Name: "origin", Type: bigquery.StringFieldType},
	{Name: "destination", Type: bigquery.StringFieldType},
	{Name: "amount", Type: bigquery.NumericFieldType},
}
metaData := &bigquery.TableMetadata{
	Schema: sampleSchema,
	TimePartitioning: &bigquery.TimePartitioning{
		Field:      "timestamp",
		Expiration: 90 * 24 * time.Hour,
	},
	Clustering: &bigquery.Clustering{
		Fields: []string{"origin", "destination"},
	},
}
tableRef := client.Dataset(datasetID).Table(tableID)
if err := tableRef.Create(ctx, metaData); err != nil {
	return err
}

Crea una tabla agrupada a partir del resultado de una consulta

Existen dos maneras de crear una tabla agrupada a partir del resultado de una consulta:

Puedes crear una tabla agrupada si realizas consultas en una tabla particionada o en una tabla sin particiones. No puedes cambiar una tabla existente a una tabla agrupada con los resultados de una consulta.

Cuando creas una tabla agrupada a partir del resultado de una consulta, debes usar SQL estándar. Por el momento, el SQL heredado no es compatible con las consultas en tablas agrupadas o la escritura de resultados de consultas en tablas agrupadas.

Console

No puedes especificar opciones de agrupamiento en clústeres para una tabla de destino cuando realizas consultas de datos con la IU web de BigQuery de Console, a menos que uses una declaración DDL. Para obtener más información, consulta Usa declaraciones de lenguaje de definición de datos.

IU clásica

No puedes especificar opciones de agrupamiento en clústeres para una tabla de destino cuando realizas consultas de datos con la IU web de BigQuery, a menos que uses una declaración DDL. Para obtener más información, consulta Usa declaraciones de lenguaje de definición de datos.

CLI

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

bq --location=location query \
--use_legacy_sql=false 'query'

En el que:

  • 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 como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • query es una consulta en la sintaxis de SQL estándar. Por el momento, no puedes usar SQL heredado para realizar consultas en las tablas agrupadas o escribir resultados de consultas en tablas agrupadas. La consulta puede incluir una declaración de DDL CREATE TABLE que especifique las opciones para crear tu tabla agrupada. Puedes usar DDL en vez de especificar las marcas de línea de comandos individuales.

Ejemplos:

Ingresa el comando siguiente para escribir resultados de consultas en una tabla de destino agrupada llamada myclusteredtable en mydataset. mydataset en tu proyecto predeterminado. La consulta recupera datos de una tabla sin particiones, mytable. La columna customer_id se usa para agrupar la tabla. La columna timestamp se usa para crear una tabla particionada.

bq query --use_legacy_sql=false \
'CREATE TABLE
   mydataset.myclusteredtable
 PARTITION BY
   DATE(timestamp)
 CLUSTER BY
   customer_id AS
 SELECT
   *
 FROM
   `mydataset.mytable`'

API

Para guardar resultados de consultas en un tabla agrupada en clústeres, llama al método jobs.insert, configura un trabajo query y, además, incluye una declaración DDL CREATE TABLE que cree tu tabla agrupada en clústeres.

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

Crea una tabla agrupada cuando cargas datos

Puedes crear una tabla agrupada si especificas columnas de agrupamiento en clústeres cuando cargas datos en una tabla nueva. No es necesario crear una tabla vacía antes de cargarle datos. Puedes crear una tabla agrupada y cargar tus datos al mismo tiempo.

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

Para definir el agrupamiento en clústeres cuando defines un trabajo de carga, haz lo siguiente:

API

Para definir la configuración de agrupamiento en clústeres cuando creas una tabla a través de un trabajo de carga, puedes propagar las propiedades Clustering de la tabla.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go incluidas en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la Documentación de referencia de la API de Go de BigQuery.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv")
gcsRef.SkipLeadingRows = 1
gcsRef.Schema = bigquery.Schema{
	{Name: "timestamp", Type: bigquery.TimestampFieldType},
	{Name: "origin", Type: bigquery.StringFieldType},
	{Name: "destination", Type: bigquery.StringFieldType},
	{Name: "amount", Type: bigquery.NumericFieldType},
}
loader := client.Dataset(destDatasetID).Table(destTableID).LoaderFrom(gcsRef)
loader.TimePartitioning = &bigquery.TimePartitioning{
	Field: "timestamp",
}
loader.Clustering = &bigquery.Clustering{
	Fields: []string{"origin", "destination"},
}
loader.WriteDisposition = bigquery.WriteEmpty

job, err := loader.Run(ctx)
if err != nil {
	return err
}
status, err := job.Wait(ctx)
if err != nil {
	return err
}

if status.Err() != nil {
	return fmt.Errorf("Job completed with error: %v", status.Err())
}

Controla el acceso a las tablas agrupadas

No puedes asignar controles de acceso a tablas o vistas de forma directa. El nivel más bajo de recursos de BigQuery al que puedes otorgar acceso es el nivel de conjunto de datos. Para configurar el acceso a las tablas y vistas, debes otorgar una función de Cloud IAM a una entidad en el nivel de conjunto de datos o superior.

Cuando 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. Para obtener información sobre cómo configurar los controles de acceso a nivel de conjunto de datos, consulta Controla el acceso a los conjuntos de datos.

También puedes otorgar funciones de Cloud IAM en un nivel superior en la jerarquía de recursos de Google Cloud Platform, como el nivel de proyecto, de carpeta o de organización. Otorgar funciones en un nivel superior le da a la entidad acceso a un conjunto más amplio de recursos. Por ejemplo, otorgar una función a una entidad en el nivel de proyecto le brinda a esa entidad permisos que se aplican a todos los conjuntos de datos del proyecto. Para obtener más información sobre cómo otorgar acceso a los recursos, consulta la página sobre cómo otorgar, cambiar y revocar el acceso a los recursos en la documentación de Cloud IAM.

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

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

Usa tablas agrupadas en clústeres

Obtén información sobre las tablas agrupadas

Puedes obtener información sobre las tablas de las siguientes formas:

  • Usa GCP Console o la IU web clásica de BigQuery.
  • Usa el comando de la CLI bq show.
  • Llama al método de la API tables.get.
  • Consulta las vistas INFORMATION_SCHEMA (Beta).

Permisos necesarios

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

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

Además, si un usuario tiene permisos bigquery.datasets.create, cuando cree un conjunto de datos se le otorgará el permiso bigquery.dataOwner para acceder a este. El acceso bigquery.dataOwner le brinda al usuario la capacidad de obtener información sobre tablas en un conjunto de datos.

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

Obtén información sobre tablas agrupadas

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

Console

  1. En el panel Recursos, haz clic en el nombre del conjunto de datos para expandirlo y, luego, en el nombre de la tabla que deseas ver.

  2. Haz clic en Detalles. Esta página muestra los detalles de la tabla que incluyen las columnas de agrupamiento en clústeres.

    Detalles de la tabla

IU clásica

  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 el nombre del conjunto de datos. Esta acción muestra las tablas y vistas del conjunto de datos.

  2. Haz clic en el nombre de la tabla.

  3. Haz clic en Detalles. La página Detalles de la tabla muestra los detalles de la tabla que incluyen las columnas de agrupamiento en clústeres.

    Detalles de tablas agrupadas

CLI

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

Si quieres obtener información sobre una tabla de un proyecto que no sea el 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 que:

  • 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 myclusteredtable en mydataset. mydataset se encuentra en tu proyecto predeterminado.

bq show --format=prettyjson mydataset.myclusteredtable

El resultado debe verse de la siguiente manera:

{
  "clustering": {
    "fields": [
      "customer_id"
    ]
  },
...
}

API

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

Obtén información sobre tablas agrupadas con INFORMATION_SCHEMA (Beta)

INFORMATION_SCHEMA es una serie de vistas que proporcionan acceso a metadatos sobre conjuntos de datos, tablas y vistas.

Puedes consultar la vista INFORMATION_SCHEMA.TABLE_OPTIONS y la vista INFORMATION_SCHEMA.TABLES para recuperar metadatos sobre tablas y vistas en un proyecto. También puedes consultar la vistas INFORMATION_SCHEMA.COLUMNS y la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para recuperar metadatos sobre las columnas (campos) en una tabla.

Para las tablas agrupadas, puedes consultar la columna CLUSTERING_ORDINAL_POSITION en la vista INFORMATION_SCHEMA.COLUMNS para recuperar información sobre tus columnas en agrupamiento en clústeres.

Vista TABLES

Cuando consultas la vista INFORMATION_SCHEMA.TABLES, los resultados de la consulta contienen una fila de cada tabla o vista en un conjunto de datos.

Las consultas hechas a la vista INFORMATION_SCHEMA.TABLES deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas o las vistas.

La vista INFORMATION_SCHEMA.TABLES tiene el esquema siguiente:

Nombre de la columna Tipo de datos Valor
TABLE_CATALOG STRING El nombre del proyecto que contiene el conjunto de datos
TABLE_SCHEMA STRING El nombre del conjunto de datos que contiene la tabla o la vista (también denominado datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también denominado tableId)
TABLE_TYPE STRING El tipo de tabla:
IS_INSERTABLE_INTO STRING YES o NO, depende de si la tabla admite declaraciones DML INSERT
IS_TYPED STRING El valor es siempre NO
CREATION_TIME TIMESTAMP La fecha y hora de creación de la tabla

Para obtener más información sobre las propiedades de los conjuntos de datos, consulta la página del recurso del conjunto de datos en la documentación de la API de REST. Si deseas obtener más información sobre las propiedades de las tablas y las vistas, consulta la página recurso de la tabla en la documentación de la API de REST.

Ejemplos

Ejemplo 1:

En el siguiente ejemplo, se recuperan todas las columnas de la vista INFORMATION_SCHEMA.TABLES, excepto is_typed, que se reserva para usarla en el futuro. Los metadatos que se muestran corresponden a todas las vistas en mydataset en tu proyecto predeterminado: myproject.

mydataset contiene las propiedades siguientes:

  • mytable1: una tabla de BigQuery estándar
  • myview1: una vista de BigQuery

Las consultas hechas a la vista INFORMATION_SCHEMA.TABLES deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en GCP Console.

    Ir a GCP Console

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Editor de consulta. INFORMATION_SCHEMA requiere sintaxis de SQL estándar. SQL estándar es la sintaxis predeterminada en GCP Console.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    
  3. Haz clic en Ejecutar.

CLI

Usa el comando query y especifica la sintaxis de SQL estándar con la marca --nouse_legacy_sql o --use_legacy_sql=false. Se requiere la sintaxis de SQL estándar para las consultas INFORMATION_SCHEMA.

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_typed)
 FROM
   mydataset.INFORMATION_SCHEMA.TABLES'

Los resultados deberían verse de la siguiente manera:

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 |
  | myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

Ejemplo 2:

En el ejemplo siguiente, se recuperan todas las tablas de tipo BASE TABLE de la vista INFORMATION_SCHEMA.TABLES. La columna is_typed queda excluida. Los metadatos que se muestran corresponden a las tablas en mydataset en tu proyecto predeterminado: myproject.

Las consultas hechas a la vista INFORMATION_SCHEMA.TABLES deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en GCP Console.

    Ir a GCP Console

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Editor de consulta. INFORMATION_SCHEMA requiere sintaxis de SQL estándar. SQL estándar es la sintaxis predeterminada en GCP Console.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    WHERE
     table_type="BASE TABLE"
    
  3. Haz clic en Ejecutar.

CLI

Usa el comando query y especifica la sintaxis de SQL estándar con la marca --nouse_legacy_sql o --use_legacy_sql=false. Se requiere la sintaxis de SQL estándar para las consultas INFORMATION_SCHEMA.

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_typed)
 FROM
   mydataset.INFORMATION_SCHEMA.TABLES
 WHERE
   table_type="BASE TABLE"'

Los resultados deberían verse de la siguiente manera:

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | NO                 | 2018-10-31 22:40:05 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

Vista TABLE_OPTIONS

Cuando consultas la vista INFORMATION_SCHEMA.TABLE_OPTIONS, los resultados de la consulta contienen una fila de cada tabla o vista del conjunto de datos.

Las consultas hechas a la vista INFORMATION_SCHEMA.TABLE_OPTIONS deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas o las vistas.

La vista INFORMATION_SCHEMA.TABLE_OPTIONS tiene el esquema siguiente:

Nombre de la columna Tipo de datos Valor
TABLE_CATALOG STRING El nombre del proyecto que contiene el conjunto de datos
TABLE_SCHEMA STRING El nombre del conjunto de datos que contiene la tabla o la vista (también denominado datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también denominado tableId)
OPTION_NAME STRING Uno de los valores de nombre en la tabla de opciones
OPTION_TYPE STRING Uno de los valores de tipo de datos en la tabla de opciones
OPTION_VALUE STRING Una de las opciones de valor en la tabla de opciones
Tabla de opciones
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 El ciclo de vida predeterminado, en días, de todos los segmentos de la tabla particionada
expiration_timestamp FLOAT64 El ciclo de vida predeterminado, en días, de la tabla
kms_key_name STRING El nombre de la clave de Cloud KMS usada para encriptar la tabla
friendly_name STRING El nombre descriptivo de la tabla
description STRING Una descripción de la tabla
labels ARRAY<STRUCT<STRING, STRING>> Un arreglo de STRUCT que representa las etiquetas en la tabla

Para obtener más información sobre las propiedades de los conjuntos de datos, consulta la página del recurso del conjunto de datos en la documentación de la API de REST. Si deseas obtener más información sobre las propiedades de las tablas y las vistas, consulta la página recurso de la tabla en la documentación de la API de REST.

Ejemplos

Ejemplo 1:

En el siguiente ejemplo, se recuperan las horas de vencimiento de la tabla predeterminada para todas las tablas en mydataset en tu proyecto predeterminado (myproject), mediante una consulta a la vista INFORMATION_SCHEMATA.TABLE_OPTIONS.

Las consultas hechas a la vista INFORMATION_SCHEMA.TABLE_OPTIONS deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en GCP Console.

    Ir a GCP Console

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Editor de consulta. INFORMATION_SCHEMA requiere sintaxis de SQL estándar. SQL estándar es la sintaxis predeterminada en GCP Console.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="expiration_timestamp"
    
  3. Haz clic en Ejecutar.

CLI

Usa el comando query y especifica la sintaxis de SQL estándar con la marca --nouse_legacy_sql o --use_legacy_sql=false. Se requiere la sintaxis de SQL estándar para las consultas INFORMATION_SCHEMA.

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
 WHERE
   option_name="expiration_timestamp"'

Los resultados deberían verse de la siguiente manera:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

Ejemplo 2:

En el ejemplo siguiente, se recuperan los metadatos sobre todas las tablas en mydataset que contienen datos de prueba. La consulta usa los valores en la opción description para encontrar tablas que contengan “prueba” en algún lugar de la descripción. mydataset está en tu proyecto predeterminado, myproject.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en GCP Console.

    Ir a GCP Console

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Editor de consulta. INFORMATION_SCHEMA requiere sintaxis de SQL estándar. SQL estándar es la sintaxis predeterminada en GCP Console.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="description" AND option_value LIKE "%test%"
    
  3. Haz clic en Ejecutar.

CLI

Usa el comando query y especifica la sintaxis de SQL estándar con la marca --nouse_legacy_sql o --use_legacy_sql=false. Se requiere la sintaxis de SQL estándar para las consultas INFORMATION_SCHEMA.

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
 WHERE
   option_name="description" AND option_value LIKE "%test%"'

Los resultados deberían verse de la siguiente manera:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

Vista COLUMNS

Cuando consultas la vista INFORMATION_SCHEMA.COLUMNS, los resultados de la consulta contienen una fila para cada columna (campo) en una tabla.

Las consultas hechas a la vista INFORMATION_SCHEMA.COLUMNS deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

La vista INFORMATION_SCHEMA.COLUMNS tiene el esquema siguiente:

Nombre de la columna Tipo de datos Valor
TABLE_CATALOG STRING El nombre del proyecto que contiene el conjunto de datos
TABLE_SCHEMA STRING El nombre del conjunto de datos que contiene la tabla (también denominado datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también denominado tableId)
COLUMN_NAME STRING El nombre de la columna
ORDINAL_POSITION INT64 El desplazamiento 1 indexado de la columna dentro de la tabla; si es una seudocolumna como _PARTITIONTIME o _PARTITIONDATE, el valor es NULL
IS_NULLABLE STRING YES o NO, lo cual depende de si el modo de la columna permite valores NULL
DATA_TYPE STRING El tipo de datos de SQL estándar de la columna
IS_GENERATED STRING El valor es siempre NEVER
GENERATION_EXPRESSION STRING El valor es siempre NULL
IS_STORED STRING El valor es siempre NULL
IS_HIDDEN STRING YES o NO, lo cual depende de si la columna es una pseudocolumna, como _PARTITIONTIME o _PARTITIONDATE
IS_UPDATABLE STRING El valor es siempre NULL
IS_SYSTEM_DEFINED STRING YES o NO, lo cual depende de si la columna es una pseudocolumna, como _PARTITIONTIME o _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES o NO lo cual depende de si la columna es una columna de partición
CLUSTERING_ORDINAL_POSITION STRING El desplazamiento 1 indexado de la columna dentro de las columnas de agrupamiento en clústeres de la tabla; el valor es NULL si la tabla no está agrupada

Para obtener más información sobre las propiedades de los conjuntos de datos, consulta la página del recurso del conjunto de datos en la documentación de la API de REST. Si deseas obtener más información sobre las propiedades de las tablas y las vistas, consulta la página recurso de la tabla en la documentación de la API de REST.

Ejemplos

En el siguiente ejemplo, se recuperan los metadatos desde la vista INFORMATION_SCHEMA.COLUMNS para la tabla population_by_zip_2010 en el conjunto de datos census_bureau_usa. Este conjunto de datos es parte del programa de conjunto de datos públicos de BigQuery.

Debido a que la tabla que consultas está en otro proyecto, bigquery-public-data, debes agregar el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view por ejemplo, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

Las columnas siguientes se excluyen de los resultados de la consulta debido a que están reservadas para uso futuro:

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE

Las consultas hechas a la vista INFORMATION_SCHEMA.COLUMNS deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en GCP Console.

    Ir a GCP Console

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Editor de consulta. INFORMATION_SCHEMA requiere sintaxis de SQL estándar. SQL estándar es la sintaxis predeterminada en GCP Console.

    SELECT
     * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
    FROM
     `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
    WHERE
     table_name="population_by_zip_2010"
    
  3. Haz clic en Ejecutar.

CLI

Usa el comando query y especifica la sintaxis de SQL estándar con la marca --nouse_legacy_sql o --use_legacy_sql=false. Se requiere la sintaxis de SQL estándar para las consultas INFORMATION_SCHEMA.

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
 FROM
   `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
 WHERE
   table_name="population_by_zip_2010"'

Los resultados deberían verse de la siguiente manera. Para una lectura mejor, table_catalog y table_schema se excluyen de los resultados:

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
  

Vista COLUMN_FIELD_PATHS

Cuando consultas la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, los resultados de la consulta contienen una fila por cada columna anidada dentro de una columna RECORD (o STRUCT).

Las consultas hechas a la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

La vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS tiene el esquema siguiente:

Nombre de la columna Tipo de datos Valor
TABLE_CATALOG >STRING El nombre del proyecto que contiene el conjunto de datos
TABLE_SCHEMA STRING El nombre del conjunto de datos que contiene la tabla (también denominado datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también denominado tableId)
COLUMN_NAME STRING El nombre de la columna
FIELD_PATH STRING La ruta a una columna anidada dentro de una columna “RECORD” (o “STRUCT”)
DATA_TYPE STRING El tipo de datos de SQL estándar de la columna
DESCRIPTION STRING La descripción de la columna

Para obtener más información sobre las propiedades de los conjuntos de datos, consulta la página del recurso del conjunto de datos en la documentación de la API de REST. Si deseas obtener más información sobre las propiedades de las tablas y las vistas, consulta la página recurso de la tabla en la documentación de la API de REST.

Ejemplos

En el siguiente ejemplo, se recuperan los metadatos de la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para la tabla commits en el conjunto de datos github_repos. Este conjunto de datos es parte del programa de conjunto de datos públicos de BigQuery.

Debido a que la tabla que consultas está en otro proyecto, bigquery-public-data, debes agregar el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view por ejemplo, `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

La tabla commits contiene las siguientes columnas anidadas, y anidadas y repetidas

  • author: columna anidada RECORD
  • committer: columna anidada RECORD
  • trailer: columna anidada y repetida RECORD
  • difference: columna anidada y repetida RECORD

Tu consulta recuperará los metadatos sobre las columnas author y difference.

Las consultas hechas a la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS deben tener un calificador de conjunto de datos. El usuario que envía la consulta debe tener acceso al conjunto de datos que contiene las tablas.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en GCP Console.

    Ir a GCP Console

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Editor de consulta. INFORMATION_SCHEMA requiere sintaxis de SQL estándar. SQL estándar es la sintaxis predeterminada en GCP Console.

    SELECT
     *
    FROM
     `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
    WHERE
     table_name="commits"
     AND column_name="author"
     OR column_name="difference"
    
  3. Haz clic en Ejecutar.

CLI

Usa el comando query y especifica la sintaxis de SQL estándar con la marca --nouse_legacy_sql o --use_legacy_sql=false. Se requiere la sintaxis de SQL estándar para las consultas INFORMATION_SCHEMA.

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
 WHERE
   table_name="commits"
   AND column_name="author"
   OR column_name="difference"'

Los resultados deberían verse de la siguiente manera. Para una lectura mejor, table_catalog y table_schema se excluyen de los resultados:

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  

Haz una lista de tablas agrupadas en un conjunto de datos

Puedes enumerar tablas agrupadas en clústeres en conjuntos de datos de las siguientes formas:

  • Usa GCP Console o la IU web clásica de BigQuery.
  • Usa el comando bq ls de la CLI.
  • Llama al método tables.list de la API.
  • Usa las bibliotecas cliente.

Los permisos y los pasos requeridos para hacer una lista de tablas agrupadas son los mismos que los de las tablas particionadas. Para obtener más información sobre cómo hacer listas de tablas, consulta Haz una lista de tablas particionadas en un conjunto de datos.

Características en desarrollo

Las siguientes características están en desarrollo, pero aún no están disponibles en la versión Alfa:

  • Compatibilidad con tablas nativas en agrupamiento en clústeres (no particionadas)
  • Reducción de costos para tipos particulares de consultas que usan filtros en columnas en agrupamiento en clústeres

Pasos siguientes

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

Enviar comentarios sobre...

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