Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Visualiza etiquetas

En esta página, se explica cómo visualizar las etiquetas de los recursos de BigQuery.

Descripción general

Puedes ver etiquetas en estas situaciones:

  • Usa la consola de Google Cloud
  • Consulta las vistas INFORMATION_SCHEMA
  • Usar el comando bq show de la herramienta de línea de comandos de bq
  • Con una llamada a los métodos datasets.gettables.get de la API
  • Con las bibliotecas cliente

Debido a que las vistas se tratan como recursos de tabla, debes usar el método tables.get para obtener información de etiquetas de las vistas y las tablas.

Antes de comenzar

Otorga funciones de administración de identidades y accesos (IAM) que les brindan a los usuarios los permisos necesarios para realizar cada tarea de este documento.

Permisos necesarios

Los permisos necesarios para ver las etiquetas dependen de los tipos de recursos a los que puedes acceder. Para realizar las tareas de este documento, necesitas los siguientes permisos.

Permisos para ver los detalles del conjunto de datos

Para ver los detalles del conjunto de datos, necesitas el permiso bigquery.datasets.get de IAM.

Cada una de las siguientes funciones de IAM predefinidas incluye los permisos que necesitas para ver los detalles del conjunto de datos:

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

Además, si tienes el permiso bigquery.datasets.create, puedes ver los detalles de los conjuntos de datos que creas.

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

Permisos para ver la tabla o los detalles

Para ver los detalles de la tabla o la vista, necesitas el permiso bigquery.tables.get de IAM.

Todas las funciones predefinidas de IAM incluyen los permisos que necesitas para ver la tabla o los detalles de la tabla, excepto roles/bigquery.user y roles/bigquery.jobUser.

Además, si tienes el permiso bigquery.datasets.create, puedes actualizar las etiquetas de las tablas y vistas en los conjuntos de datos que crees.

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

Permisos para detalles del trabajo

Para ver los detalles del trabajo, necesitas el permiso bigquery.jobs.get de IAM.

Cada una de las siguientes funciones de IAM predefinidas incluye los permisos que necesitas para ver los detalles del trabajo:

  • roles/bigquery.admin (te permite ver detalles de todos los trabajos del proyecto)
  • roles/bigquery.user (te permite ver detalles de tus trabajos)
  • roles/bigquery.jobUser (te permite ver detalles de tus trabajos)

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

Cómo ver etiquetas de conjunto de datos, tabla y vista

Para ver las etiquetas de un recurso, selecciona una de las siguientes opciones:

Console

  1. Para los conjuntos de datos, la página Detalles de conjuntos de datos (Dataset Details) se abre de forma automática. Para las tablas y vistas, haz clic en Details (Detalles) a fin de abrir la página de detalles. La información de la etiqueta aparece en la tabla de información del recurso.

    Detalles de la tabla

SQL

Consulta la vista INFORMATION_SCHEMA.SCHEMATA_OPTIONS para ver las etiquetas de un conjunto de datos o la vista INFORMATION_SCHEMA.TABLE_OPTIONS para ver las etiquetas en una tabla. Por ejemplo, la siguiente consulta de SQL muestra las etiquetas en el conjunto de datos llamado mydataset:

  1. En la consola de Google Cloud, ve a la página de BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, ingresa la siguiente sentencia:

    SELECT
      *
    FROM
      INFORMATION_SCHEMA.SCHEMATA_OPTIONS
    WHERE
      schema_name = 'mydataset'
      AND option_name = 'labels';
    

  3. Haz clic en Ejecutar.

Si quieres obtener información para ejecutar consultas, visita Ejecuta consultas interactivas.

bq

Usa el comando bq show con el ID del recurso. La marca --format se puede usar para controlar el resultado. Si el recurso está en un proyecto que no es el predeterminado, debes agregar el ID del proyecto al comando con el siguiente formato: [PROJECT_ID]:[DATASET]. A fin de facilitar la lectura, puedes configurar la marca --format en pretty para controlar el resultado.

bq show --format=pretty [RESOURCE_ID]

Donde [RESOURCE_ID] es un conjunto de datos válido, tabla, vista o ID de trabajo.

Ejemplos:

Ingresa el siguiente comando a fin de mostrar etiquetas para mydataset en tu proyecto predeterminado.

bq show --format=pretty mydataset

El resultado se verá de la siguiente manera:

+-----------------+--------------------------------------------------------+---------------------+
|  Last modified  |                          ACLs                          |       Labels        |
+-----------------+--------------------------------------------------------+---------------------+
| 11 Jul 19:34:34 | Owners:                                                | department:shipping |
|                 |   projectOwners,                                       |                     |
|                 | Writers:                                               |                     |
|                 |   projectWriters                                       |                     |
|                 | Readers:                                               |                     |
|                 |   projectReaders                                       |                     |
+-----------------+--------------------------------------------------------+---------------------+

Ingresa el siguiente comando a fin de mostrar etiquetas para mydataset.mytable. mydataset está en myotherproject, no en tu proyecto predeterminado.

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

En el caso de una tabla agrupada en clústeres, el aspecto del resultado será el siguiente:

+-----------------+------------------------------+------------+-------------+-----------------+------------------------------------------------+------------------+---------+
|  Last modified  |            Schema            | Total Rows | Total Bytes |   Expiration    |               Time Partitioning                | Clustered Fields | Labels  |
+-----------------+------------------------------+------------+-------------+-----------------+------------------------------------------------+------------------+---------+
| 25 Jun 19:28:14 | |- timestamp: timestamp      | 0          | 0           | 25 Jul 19:28:14 | DAY (field: timestamp, expirationMs: 86400000) | customer_id      | org:dev |
|                 | |- customer_id: string       |            |             |                 |                                                |                  |         |
|                 | |- transaction_amount: float |            |             |                 |                                                |                  |         |
+-----------------+------------------------------+------------+-------------+-----------------+------------------------------------------------+------------------+---------+

API

Realiza una llamada al método datasets.get o al método tables.get. En la respuesta, se incluyen todas las etiquetas asociadas con ese recurso.

Como alternativa, puedes usar datasets.list para visualizar las etiquetas de varios conjuntos de datos o tables.list para visualizar las etiquetas de varias tablas y vistas.

Debido a que las vistas se tratan como recursos de tabla, debes usar los métodos tables.gettables.list a fin de visualizar la información de etiquetas para las vistas y las tablas.

Go

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

import (
	"context"
	"fmt"
	"io"

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

// printDatasetLabels retrieves label metadata from a dataset and prints it to an io.Writer.
func printDatasetLabels(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	meta, err := client.Dataset(datasetID).Metadata(ctx)
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "Dataset %s labels:\n", datasetID)
	if len(meta.Labels) == 0 {
		fmt.Fprintln(w, "Dataset has no labels defined.")
		return nil
	}
	for k, v := range meta.Labels {
		fmt.Fprintf(w, "\t%s:%s\n", k, v)
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;

// Sample to get dataset labels
public class GetDatasetLabels {

  public static void runGetDatasetLabels() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    getDatasetLabels(datasetName);
  }

  public static void getDatasetLabels(String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Dataset dataset = bigquery.getDataset(datasetName);
      dataset
          .getLabels()
          .forEach((key, value) -> System.out.println("Retrieved labels successfully"));
    } catch (BigQueryException e) {
      System.out.println("Label was not found. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

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

async function getDatasetLabels() {
  // Gets labels on a dataset.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";

  // Retrieve current dataset metadata.
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();
  const labels = metadata.labels;

  console.log(`${datasetId} Labels:`);
  for (const [key, value] of Object.entries(labels)) {
    console.log(`${key}: ${value}`);
  }
}
getDatasetLabels();

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.


from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = "your-project.your_dataset"

dataset = client.get_dataset(dataset_id)  # Make an API request.

# View dataset labels.
print("Dataset ID: {}".format(dataset_id))
print("Labels:")
if dataset.labels:
    for label, value in dataset.labels.items():
        print("\t{}: {}".format(label, value))
else:
    print("\tDataset has no labels defined.")

Visualiza etiquetas de la tabla

Go

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

import (
	"context"
	"fmt"
	"io"

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

// tableLabels demonstrates fetching metadata from a table and printing the Label metadata to an io.Writer.
func tableLabels(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "Table %s labels:\n", datasetID)
	if len(meta.Labels) == 0 {
		fmt.Fprintln(w, "Table has no labels defined.")
		return nil
	}
	for k, v := range meta.Labels {
		fmt.Fprintf(w, "\t%s:%s\n", k, v)
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

// Sample to get table labels
public class GetTableLabels {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    getTableLabels(datasetName, tableName);
  }

  public static void getTableLabels(String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // This example table starts with existing label { color: 'green' }
      Table table = bigquery.getTable(TableId.of(datasetName, tableName));
      table
          .getLabels()
          .forEach((key, value) -> System.out.println("Retrieved labels successfully"));
    } catch (BigQueryException e) {
      System.out.println("Label was not deleted. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

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

async function getTableLabels() {
  // Gets labels on a dataset.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // Retrieve current dataset metadata.
  const table = bigquery.dataset(datasetId).table(tableId);
  const [metadata] = await table.getMetadata();
  const labels = metadata.labels;

  console.log(`${tableId} Labels:`);
  for (const [key, value] of Object.entries(labels)) {
    console.log(`${key}: ${value}`);
  }
}
getTableLabels();

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'
# table_id = 'my_table'

project = client.project
dataset_ref = bigquery.DatasetReference(project, dataset_id)
table_ref = dataset_ref.table(table_id)
table = client.get_table(table_ref)  # API Request

# View table labels
print("Table ID: {}".format(table_id))
print("Labels:")
if table.labels:
    for label, value in table.labels.items():
        print("\t{}: {}".format(label, value))
else:
    print("\tTable has no labels defined.")

Visualiza etiquetas de trabajo

Para ver las etiquetas de un trabajo, selecciona una de las opciones siguientes:

SQL

Consulta las vistas INFORMATION_SCHEMA.JOB_BY_* para ver las etiquetas de un trabajo. Por ejemplo, la siguiente consulta en SQL muestra el texto de la consulta y las etiquetas en los trabajos que envió el usuario actual en el proyecto actual:

  1. En la consola de Google Cloud, ve a la página de BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, ingresa la siguiente sentencia:

    SELECT
      query,
      labels
    FROM
      INFORMATION_SCHEMA.JOBS_BY_USER;
    

  3. Haz clic en Ejecutar.

Si quieres obtener información para ejecutar consultas, visita Ejecuta consultas interactivas.

bq

Para ver las etiquetas de un trabajo de consulta mediante la herramienta de línea de comandos de bq, ingresa el comando bq show -j con el ID del trabajo de consulta. La marca --format se puede usar para controlar el resultado. Por ejemplo, si tu trabajo de consulta tiene el ID de tarea bqjob_r1234d57f78901_000023746d4q12_1, ingresa el siguiente comando:

bq show -j --format=pretty bqjob_r1234d57f78901_000023746d4q12_1

El resultado debe tener el siguiente aspecto:

+----------+---------+-----------------+----------+-------------------+-----------------+--------------+----------------------+
| Job Type |  State  |   Start Time    | Duration |    User Email     | Bytes Processed | Bytes Billed |        Labels        |
+----------+---------+-----------------+----------+-------------------+-----------------+--------------+----------------------+
| query    | SUCCESS | 03 Dec 15:00:41 | 0:00:00  | email@example.com | 255             | 10485760     | department:shipping  |
|          |         |                 |          |                   |                 |              | costcenter:logistics |
+----------+---------+-----------------+----------+-------------------+-----------------+--------------+----------------------+

API

Realiza una llamada al método jobs.get. En la respuesta, se incluyen todas las etiquetas asociadas con ese recurso.

Pasos siguientes