Crea y usa tablas

En este documento, se describe cómo crear y usar tablas en BigQuery. Después de crear una tabla, puedes hacer lo siguiente:

  • Controlar el acceso a los datos de tus tablas
  • Obtener información sobre tus tablas
  • Enumerar las tablas en un conjunto de datos
  • Obtener metadatos de las tablas

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

Limitaciones de las tablas

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

  • Los nombres de las tablas deben ser únicos en cada conjunto de datos.
  • La consola y la IU web clásica de BigQuery permiten copiar solo una tabla a la vez.
  • Cuando se copia una tabla, el conjunto de datos de destino debe residir en la misma ubicación que la tabla que se copia. Por ejemplo, no puedes copiar una tabla de un conjunto de datos que reside en la UE a un conjunto de datos que reside en EE.UU.
  • Cuando se copian varias tablas de origen a una tabla de destino con la CLI o la API, todas las tablas de origen deben tener esquemas idénticos.
  • Solo puedes borrar una tabla a la vez con la consola, la IU web clásica de BigQuery, la herramienta de línea de comandos o la API.
  • Cuando se exportan los datos de las tablas, el único destino admitido es Cloud Storage.

  • Cuando hay 50,000 tablas o más en un conjunto de datos, enumerarlas se vuelve más lento. El rendimiento de la enumeración se ve afectado si usas una llamada a la API o la IU web clásica de BigQuery. En la actualidad, la IU web de BigQuery en GCP Console te permite mostrar solo 50,000 tablas por conjunto de datos.

    Para mejorar el rendimiento de la IU web clásica de BigQuery, puedes usar el parámetro ?minimal a fin de limitar el número de tablas mostradas a 30,000 tablas por proyecto. Debes agregar el parámetro a la URL de la IU web clásica de BigQuery con el siguiente formato: https://bigquery.cloud.google.com/queries/[PROJECT_NAME]?minimal.

Crea una tabla

Puedes crear una tabla en BigQuery de las siguientes maneras:

  • De forma manual con la IU web de BigQuery o el comando bq mk de la herramienta de línea de comandos
  • De manera programática, mediante una llamada al método de la API tables.insert
  • Desde resultados de consultas
  • Mediante la definición de una tabla que hace referencia a una fuente de datos externa
  • Cuando cargas datos

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:

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

Permisos necesarios

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

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

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

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

Cuando creas una tabla 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 deseas obtener más información sobre cómo especificar un esquema de tabla, consulta Especifica un esquema.

Después de crear la tabla, puedes cargarle datos o propagarla mediante la escritura de resultados de consulta.

Para crear una tabla vacía con una definición de esquema, haz lo siguiente:

IU clásica

  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 tabla nueva).

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

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

    • En Table name (Nombre de tabla), elige el conjunto de datos apropiado y, en el campo de nombre de tabla, ingresa el nombre de la tabla que deseas crear.
    • Verifica que Table type (Tipo de tabla) esté configurado como Native table (Tabla nativa).

  4. En la sección Schema (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 Edit as text (Editar como texto) y luego ingresa el esquema de tabla como un arreglo JSON:

        Agregar un esquema como arreglo de JSON

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

        Agregar un esquema con agregar campos

  5. En la sección Options (Opciones), usa los valores predeterminados.

  6. Haz clic en Create Table.

Línea de comandos

Usa el comando mk con las marcas --table o -t. Puedes suministrar la informació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_type, --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].

--time_partitioning_type y --destination_kms_key no se muestran aquí. Para obtener más información sobre --time_partitioning_type, consulta tablas particionadas por tiempo de transferencia o tablas particionadas. Para obtener más información sobre --destination_kms_key, consulta claves de encriptación que administra el cliente.

Para crear una tabla vacía en un conjunto de datos existente con una definición de esquema, ingresa lo siguiente:

bq mk --table --expiration [INTEGER] --description [DESCRIPTION] --label [KEY:VALUE, KEY:VALUE] [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]

En el que:

  • [INTEGER] es el tiempo de vida predeterminado de la tabla (en segundos). El valor mínimo es 3,600 segundos (una hora). El vencimiento se evalúa según la fecha actual más el valor del número entero. Si configuras el vencimiento cuando creas una tabla, se ignora la configuración predeterminada de vencimiento de tablas del conjunto de datos.
  • [DESCRIPTION] es una descripción de la tabla entre comillas.
  • [KEY:VALUE] es el par clave-valor que representa una etiqueta. Puedes ingresar varias etiquetas mediante 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 que creas.
  • [SCHEMA] es una definición de esquema intercalado en el formato [FIELD]:[DATA_TYPE],[FIELD]:[DATA_TYPE] o la ruta de acceso 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 RECORD (STRUCT) ni una descripción de 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 siguiente comando para crear una tabla con una definición de esquema intercalada. Este comando crea una tabla llamada mytable en mydataset en tu proyecto predeterminado. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción en This is my table y la etiqueta en organization:development. El comando usa el acceso directo -t en lugar de --table. El esquema se especifica de forma intercalada así: qtr:STRING,sales:FLOAT,year:STRING.

bq mk -t --expiration 3600 --description "This is my table" --label organization:development mydataset.mytable qtr:STRING,sales:FLOAT,year:STRING

Ingresa el siguiente comando para crear una tabla con un archivo de esquema JSON. Este comando crea una tabla llamada mytable en mydataset en tu proyecto predeterminado. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción en This is my table y la etiqueta en organization:development. La ruta de acceso al archivo de esquema es /tmp/myschema.json.

bq mk --table --expiration 3600 --description "This is my table" --label organization:development mydataset.mytable /tmp/myschema.json

Ingresa el siguiente comando para crear una tabla con un archivo de esquema JSON. Este comando crea una tabla llamada mytable en mydataset en myotherproject. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción en This is my table y la etiqueta en organization:development. La ruta de acceso al archivo de esquema es /tmp/myschema.json.

bq mk --table --expiration 3600 --description "This is my table" --label organization:development myotherproject:mydataset.mytable /tmp/myschema.json

Una vez que se crea la tabla, puedes actualizar el vencimiento, la descripción y las etiquetas. También puedes modificar la definición de esquema.

API

Llama al método tables.insert con un recurso de tabla definido.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# de la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de C# de BigQuery. 

using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Go

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

sampleSchema := bigquery.Schema{
	{Name: "full_name", Type: bigquery.StringFieldType},
	{Name: "age", Type: bigquery.IntegerFieldType},
}

metaData := &bigquery.TableMetadata{
	Schema:         sampleSchema,
	ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
}
tableRef := client.Dataset(datasetID).Table(tableID)
if err := tableRef.Create(ctx, metaData); err != nil {
	return err
}

Java

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

TableId tableId = TableId.of(datasetName, tableName);
// Table field definition
Field field = Field.of(fieldName, LegacySQLTypeName.STRING);
// Table schema definition
Schema schema = Schema.of(field);
TableDefinition tableDefinition = StandardTableDefinition.of(schema);
TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();
Table table = bigquery.create(tableInfo);

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js de la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery. 

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = "your-project-id";
// const datasetId = "my_new_dataset";
// const tableId = "my_new_table";
// const schema = "Name:string, Age:integer, Weight:float, IsMagic:boolean";

// Creates a client
const bigquery = new BigQuery({projectId});

// For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
const options = {schema};

// Create a new table in the dataset
const [table] = await bigquery
  .dataset(datasetId)
  .createTable(tableId, options);

console.log(`Table ${table.id} created.`);

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para 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_ref = client.dataset('my_dataset')

schema = [
    bigquery.SchemaField('full_name', 'STRING', mode='REQUIRED'),
    bigquery.SchemaField('age', 'INTEGER', mode='REQUIRED'),
]
table_ref = dataset_ref.table('my_table')
table = bigquery.Table(table_ref, schema=schema)
table = client.create_table(table)  # API request

assert table.table_id == 'my_table'

Ruby

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

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

Crea una tabla a partir de un resultado de consulta

Para crear una tabla a partir de un resultado de consulta, escribe los resultados en una tabla de destino.

IU clásica

  1. Dirígete a la IU web clásica de BigQuery.
    Ir a la IU web clásica de BigQuery

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

  3. Ingresa una consulta de SQL válida en BigQuery en el área de texto New Query (Consulta nueva).

  4. Haz clic en Show options (Mostrar opciones).

  5. En la sección Destination Table, haz clic en Select Table (Seleccionar tabla).

  6. En el cuadro de diálogo Select Destination Table (Seleccionar tabla de destino), haz lo siguiente:

    1. En Project (Proyecto), elige el proyecto en el que se creará la tabla de destino.

    2. En Dataset (Conjunto de datos), elige el conjunto de datos que almacenará la tabla.

    3. En el campo Table ID (ID de la tabla), ingresa un nombre de tabla. El nombre debe ser único en el conjunto de datos de destino. El nombre de la tabla puede tener hasta 1,024 caracteres de la A a la Z (mayúsculas o minúsculas), números del 0 al 9, o _ (el carácter de guion bajo).

    4. Haz clic en OK.

  7. En la sección Destination Table, en Write Preference (Preferencia de escritura), elige una de las siguientes opciones:

    • Write if empty (Escribir si está vacía): escribe los resultados de las consultas en la tabla solo si esta está vacía.
    • Append to table (Agregar a la tabla): agrega los resultados de las consultas a una tabla existente.
    • Overwrite table (Reemplazar tabla): reemplaza una tabla existente con el mismo nombre con los resultados de las consultas.

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

  9. Haz clic en Run query (Ejecutar consulta). Esto crea un trabajo de consulta que escribe los resultados de las consultas en la tabla que especificaste.

Como alternativa, si olvidas especificar una tabla de destino antes de ejecutar tu consulta, puedes hacer clic en el botón Save as Table (Guardar como tabla) en la ventana de resultados para copiar la tabla temporal en una tabla permanente.

CLI

Ingresa el comando bq query y especifica la marca --destination_table para crear una tabla permanente basada en los resultados de las consultas. Especifica la marca use_legacy_sql=false para usar la sintaxis de SQL estándar. A fin de escribir los resultados de las consultas en una tabla que no se encuentra en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el siguiente formato: [PROJECT_ID]:[DATASET].

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

Para controlar la disposición de escritura de una tabla de destino existente, especifica una de las siguientes marcas opcionales:

  • --append_table: si existe la tabla de destino, los resultados de las consultas se agregan a ella.

  • --replace: si existe la tabla de destino, se reemplaza con los resultados de las consultas.

    bq --location=[LOCATION] query --destination_table [PROJECT_ID]:[DATASET].[TABLE] --use_legacy_sql=false '[QUERY]'

En el que:

  • [LOCATION] es el nombre de la ubicación que se usa para procesar la consulta. 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 establecer un valor predeterminado para la ubicación mediante el archivo .bigqueryrc.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla en la que escribes los resultados de las consultas.
  • [TABLE] es el nombre de la tabla en la que escribes los resultados de las consultas.
  • [QUERY] es una consulta en la sintaxis de SQL estándar.

Si no se especifica una marca de disposición de escritura, el comportamiento predeterminado es escribir los resultados en la tabla solo si está vacía. Si la tabla existe y no está vacía, se muestra el siguiente error: BigQuery error in query operation: Error processing job '[PROJECT_ID]:bqjob_123abc456789_00000e1234f_1': Already Exists: Table [PROJECT_ID]:[DATASET].[TABLE].

Ejemplos:

Ingresa el siguiente comando para escribir los resultados de las consultas en una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. Debido a que no se especifica ninguna marca de disposición de escritura en el comando, la tabla debe ser nueva o estar vacía. De lo contrario, se muestra un error Already exists. La consulta recupera datos del conjunto de datos públicos Datos de nombres de EE.UU.

bq --location=US query --destination_table mydataset.mytable --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 a fin de usar los resultados de las consultas para reemplazar una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. El comando usa la marca --replace para reemplazar la tabla de destino.

bq --location=US query --destination_table mydataset.mytable --replace --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 agregar los resultados de las consultas a una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en myotherproject, no en tu proyecto predeterminado. El comando usa la marca --append para agregar los resultados de las consultas en la tabla de destino.

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

API

A fin de guardar los resultados de las consultas en una tabla permanente, llama al método jobs.insert, configura un trabajo de query y, por último, incluye un valor para la propiedad configuration.query.destinationTable. Para controlar la disposición de escritura de una tabla de destino existente, configura la propiedad configuration.query.writeDisposition.

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

Go

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

bigquery/snippets/snippet.go 
// 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")

q := client.Query("SELECT 17 as my_col")
q.Location = "US" // Location must match the dataset(s) referenced in query.
q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
job, err := q.Run(ctx)
if err != nil {
	return err
}
status, err := job.Wait(ctx)
if err != nil {
	return err
}
if err := status.Err(); err != nil {
	return err
}
it, err := job.Read(ctx)
for {
	var row []bigquery.Value
	err := it.Next(&row)
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	fmt.Println(row)
}

Java

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

Para guardar los resultados de las consultas en una tabla permanente, configura la tabla de destino como el TableId deseado en QueryJobConfiguration.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
// String destinationDataset = 'my_destination_dataset';
// String destinationTable = 'my_destination_table';
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    // Note that setUseLegacySql is set to false by default
    QueryJobConfiguration.newBuilder(query)
        // Save the results of the query to a permanent table.
        .setDestinationTable(TableId.of(destinationDataset, destinationTable))
        .build();

// Print the results.
for (FieldValueList row : bigquery.query(queryConfig).iterateAll()) {
  for (FieldValue val : row) {
    System.out.printf("%s,", val.toString());
  }
  System.out.printf("\n");
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

Si quieres guardar los resultados de las consultas en una tabla permanente, crea una QueryJobConfig y establece el destino en la TableReference que desees. Pasa la configuración del trabajo al método de consulta. 

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'your_dataset_id'

job_config = bigquery.QueryJobConfig()
# Set the destination table
table_ref = client.dataset(dataset_id).table('your_table_id')
job_config.destination = table_ref
sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(
    sql,
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config)  # API request - starts the query

query_job.result()  # Waits for the query to finish
print('Query results loaded to table {}'.format(table_ref.path))

Crea una tabla que hace referencia a una fuente de datos externa

Una fuente de datos externa (también conocida como fuente de datos federada) es una fuente de datos que puedes consultar de forma directa, aunque los datos no estén almacenados en BigQuery. En lugar de cargar o transmitir los datos, debes crear una tabla que hace referencia a la fuente de datos externa.

BigQuery admite consultas de datos de forma directa desde:

Puedes consultar los datos en una fuente de datos externa compatible mediante la creación de una tabla temporal o permanente que hace referencia a los datos almacenados en la fuente de datos externa. Para obtener más información sobre cómo trabajar con fuentes de datos externas, lee los siguientes artículos:

Crea una tabla cuando cargas datos

Cuando cargas datos en BigQuery, puedes cargarlos en una nueva tabla o partición, puedes agregar datos a una tabla o partición existentes, o puedes reemplazar una tabla o partición. No es necesario crear una tabla vacía antes de cargarle datos. Puedes crear la tabla nueva y cargar tus datos al mismo tiempo.

Cuando cargas datos en BigQuery, puedes suministrar el esquema de tabla o de partición; si el formato de los datos es compatible, puedes usar la detección automática de esquemas.

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

Controla el acceso a las tablas

No puedes asignar controles de acceso a las tablas de forma directa. Puedes controlar el acceso a las tablas si configuras los controles de acceso a nivel del conjunto de datos o a nivel del proyecto.

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

En lugar de otorgar acceso a conjuntos de datos individuales, puedes asignar funciones de IAM predefinidas a nivel del proyecto que otorguen permisos sobre 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 deseas que realice el usuario, el grupo o la cuenta de servicio.

Si quieres obtener más información sobre funciones y permisos, consulta las siguientes secciones:

Para obtener información sobre cómo trabajar con datos de tablas, consulta Administra datos de tablas.

Usa tablas

Obtén información sobre las tablas

Puedes obtener información o metadatos sobre las tablas de las siguientes maneras:

  • Mediante GCP Console o la IU web clásica de BigQuery
  • Mediante el comando de CLI bq show
  • Mediante una llamada al método de la API tables.get
  • Mediante consultas sobre las vistas INFORMATION_SCHEMA (Beta)

Permisos necesarios

Para obtener información sobre las tablas, debes tener asignada la función de READER en el conjunto de datos o una función de IAM a nivel del proyecto que incluya permisos bigquery.tables.get. Si tienes permisos bigquery.tables.get a nivel del proyecto, puedes obtener información sobre todas las tablas del proyecto. Todas las funciones de IAM predefinidas a nivel del proyecto incluyen los permisos de 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 permite que un usuario con la función bigquery.user obtenga información sobre las tablas en cualquier conjunto de datos que cree. Cuando un usuario asignado a la función bigquery.user crea un conjunto de datos, se otorga acceso de OWNER al conjunto de datos. El acceso de OWNER a un conjunto de datos le otorga al usuario control completo sobre él y todas las tablas que contenga.

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

Obtén información de las tablas

Para obtener información sobre las tablas, haz lo siguiente:

IU clásica

  1. En el panel de navegación, haz clic en el ícono de flecha hacia abajo ícono de flecha hacia abajo a la izquierda de tu conjunto de datos para expandirlo, o haz doble clic en el nombre del conjunto. 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). En la página Table Details (Detalles de la tabla), se muestra la descripción y la información de la tabla.

    Ver detalles de la tabla

  4. Haz clic en la pestaña Schema para ver la definición del esquema de la tabla.

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

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

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

API

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

Go

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

meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
if err != nil {
	return err
}
// Print basic information about the table.
fmt.Printf("Schema has %d top-level fields\n", len(meta.Schema))
fmt.Printf("Description: %s\n", meta.Description)
fmt.Printf("Row in managed storage: %d\n", meta.NumRows)

Java

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

TableId tableId = TableId.of(projectId, datasetName, tableName);
Table table = bigquery.getTable(tableId);

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
//$projectId = 'The Google project ID';
//$datasetId = 'The BigQuery dataset ID';
//$tableId   = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para 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'

dataset_ref = client.dataset(dataset_id)
table_ref = dataset_ref.table(table_id)
table = client.get_table(table_ref)  # API Request

# View table properties
print(table.schema)
print(table.description)
print(table.num_rows)

Obtén información sobre tablas 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 las vistas INFORMATION_SCHEMA.TABLES y INFORMATION_SCHEMA.TABLE_OPTIONS para recuperar metadatos sobre las tablas y vistas en un proyecto. También puedes consultar las vistas INFORMATION_SCHEMA.COLUMNS y INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para recuperar metadatos sobre las columnas (campos) de una tabla.

Las vistas TABLES y TABLE_OPTIONS también contienen información de alto nivel sobre las vistas. Para obtener información detallada, consulta la vista INFORMATION_SCHEMA.VIEWS en su lugar.

Vista TABLES

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

Las consultas sobre 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 vistas.

La vista INFORMATION_SCHEMA.TABLES tiene el siguiente esquema:

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 conocido como datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también conocido como tableId)
TABLE_TYPE STRING El tipo de tabla:
IS_INSERTABLE_INTO STRING YES o NO, lo cual depende de si la tabla es compatible con las declaraciones DML INSERT
IS_TYPED STRING El valor siempre es NO
CREATION_TIME TIMESTAMP La fecha de creación de la tabla

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 tablas en mydataset en tu proyecto predeterminado (myproject).

mydataset contiene las siguientes tablas:

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

Las consultas sobre 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 con 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 la IU web de BigQuery

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Query editor (Editor de consulta). INFORMATION_SCHEMA requiere la 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 Run (Ejecutar).

Línea de comandos

Usa el comando query y especifica la sintaxis de SQL estándar con las marcas --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 manera siguiente:

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | 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. Se excluye la columna is_typed. Los metadatos que se muestran corresponden a las tablas en mydataset en tu proyecto predeterminado (myproject).

Las consultas sobre 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 con 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 la IU web de BigQuery

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Query editor. INFORMATION_SCHEMA requiere la 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 Run.

Línea de comandos

Usa el comando query y especifica la sintaxis de SQL estándar con las marcas --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 manera siguiente:

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | 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 por cada tabla o vista en un conjunto de datos.

Las consultas sobre 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 vistas.

La vista INFORMATION_SCHEMA.TABLE_OPTIONS tiene el siguiente esquema:

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 conocido como datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también conocido como 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 tiempo de vida predeterminado de todas las particiones de una tabla particionada, en días
expiration_timestamp FLOAT64 El tiempo de vida predeterminado de la tabla, en días
kms_key_name STRING El nombre de la clave de Cloud KMS que se usa 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

Ejemplos

Ejemplo 1:

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

Las consultas sobre 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 con 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 la IU web de BigQuery

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Query editor. INFORMATION_SCHEMA requiere la 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 Run.

Línea de comandos

Usa el comando query y especifica la sintaxis de SQL estándar con las marcas --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 manera siguiente:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | 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 de todas las tablas en mydataset que contienen datos de prueba. La consulta usa los valores en la opción description para encontrar las tablas que contengan “test” en algún lugar de la descripción. mydataset se encuentra 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 con el siguiente formato: `[PROJECT_ID]:[DATASET].INFORMATION_SCHEMA.[VIEW]`, por ejemplo, `myproject:mydataset.INFORMATION_SCHEMA.SCHEMATA_OPTIONS`.

Para ejecutar la consulta, haz lo siguiente:

Console

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

    Ir a la IU web de BigQuery

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Query editor. INFORMATION_SCHEMA requiere la 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 Run.

Línea de comandos

Usa el comando query y especifica la sintaxis de SQL estándar con las marcas --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 manera siguiente:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | 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 por cada columna (campo) de una tabla.

Las consultas sobre 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 siguiente esquema:

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 conocido como datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también conocido como tableId)
COLUMN_NAME STRING El nombre de la columna
ORDINAL_POSITION INT64 El desplazamiento con índice 1 de la columna dentro de la tabla; si es una pseudocolumna como _PARTITIONTIME o _PARTITIONDATE, el valor es NULL
IS_NULLABLE STRING YES o NO, 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 siempre es NEVER
GENERATION_EXPRESSION STRING El valor siempre es NULL
IS_STORED STRING El valor siempre es NULL
IS_HIDDEN STRING YES o NO, depende de si la columna es una pseudocolumna, como _PARTITIONTIME o _PARTITIONDATE
IS_UPDATABLE STRING El valor siempre es NULL
IS_SYSTEM_DEFINED STRING YES o NO, depende de si la columna es una pseudocolumna, como _PARTITIONTIME o _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES o NO, depende de si la columna es una columna de partición
CLUSTERING_ORDINAL_POSITION STRING El desplazamiento con índice 1 de la columna dentro de las columnas de agrupamiento en clústeres de la tabla; el valor es NULL si la tabla no es una tabla agrupada

Ejemplos

En el ejemplo siguiente, 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 conjuntos de datos públicos de BigQuery.

Debido a que esta tabla se encuentra en el proyecto bigquery-public-data, debes agregar el ID del proyecto al conjunto de datos con el formato siguiente: `[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 sobre 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 la IU web de BigQuery

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Query editor. INFORMATION_SCHEMA requiere la 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 Run.

Línea de comandos

Usa el comando query y especifica la sintaxis de SQL estándar con las marcas --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 tener el siguiente aspecto. Para mayor legibilidad, 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 sobre 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 siguiente esquema:

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 conocido como datasetId)
TABLE_NAME STRING El nombre de la tabla o la vista (también conocido como tableId)
COLUMN_NAME STRING El nombre de la columna
FIELD_PATH STRING La ruta de acceso 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

Ejemplos

En el ejemplo siguiente, 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 conjuntos de datos públicos de BigQuery.

Debido a que esta tabla se encuentra en el proyecto bigquery-public-data, debes agregar el ID del proyecto al conjunto de datos con el formato siguiente: `[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 columnas anidadas y repetidas:

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

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

Las consultas sobre 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 la IU web de BigQuery

  2. Ingresa la siguiente consulta de SQL estándar en la casilla Query editor. INFORMATION_SCHEMA requiere la 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 Run.

Línea de comandos

Usa el comando query y especifica la sintaxis de SQL estándar con las marcas --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 tener el siguiente aspecto. Para mayor legibilidad, 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        |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+

Enumera tablas en un conjunto de datos

Puedes enumerar tablas en conjuntos de datos mediante la IU web de BigQuery, el comando bq ls de la CLI o una llamada al método de la API tables.list.

Permisos necesarios

Para enumerar las tablas en un conjunto de datos, debes tener asignada la función READER en el conjunto de datos o una función de IAM a nivel del proyecto con permisos de bigquery.tables.list. Si se te otorgan permisos de bigquery.tables.list a nivel del proyecto, puedes enumerar las tablas en cualquier conjunto de datos del proyecto. Todas las funciones de IAM predefinidas a nivel del proyecto incluyen permisos de 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. A fin de obtener más información sobre las funciones a nivel del conjunto de datos, consulta Funciones básicas para conjuntos de datos.

Enumera tablas

Para enumerar las tablas en un conjunto de datos, 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 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 se identifican con íconos diferentes.

    Ver tablas

Línea de comandos

Ejecuta el comando bq ls. La marca --format puede usarse para controlar el resultado. Si enumeras 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]

En el que:

  • [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. Por ejemplo:

+-------------------------+-------+----------------------+-------------------+
|         tableId         | Type  |        Labels        | Time Partitioning |
+-------------------------+-------+----------------------+-------------------+
| mytable                 | TABLE | department:shipping  |                   |
| myview                  | VIEW  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

Ejemplos:

Ingresa el siguiente comando para enumerar las tablas del conjunto de datos mydataset en tu proyecto predeterminado.

bq ls --format=pretty mydataset

Ingresa el siguiente comando para enumerar las tablas del conjunto de datos mydataset en myotherproject.

bq ls --format=pretty myotherproject:mydataset

API

Para enumerar las tablas con la API, llama al método tables.list.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# de la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de C# de BigQuery. 

using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

Go

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

ts := client.Dataset(datasetID).Tables(ctx)
for {
	t, err := ts.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "Table: %q\n", t.TableID)
}

Java

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

DatasetId datasetId = DatasetId.of(projectId, datasetName);
Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
for (Table table : tables.iterateAll()) {
  // do something with the table
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js de la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery. 

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

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

// Creates a client
const bigquery = new BigQuery({projectId});

// Lists all tables in the dataset
const [tables] = await bigquery.dataset(datasetId).getTables();

console.log('Tables:');
tables.forEach(table => console.log(table.id));

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para 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_ref = client.dataset('my_dataset')

tables = list(client.list_tables(dataset_ref))  # API request(s)
assert len(tables) == 0

table_ref = dataset.table('my_table')
table = bigquery.Table(table_ref)
client.create_table(table)                  # API request
tables = list(client.list_tables(dataset))  # API request(s)

assert len(tables) == 1
assert tables[0].table_id == 'my_table'

Ruby

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

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

Pasos siguientes

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Esta página
Comentarios sobre la documentación
BigQuery
Comentarios sobre el producto
¿Necesitas ayuda? Visita nuestra página de asistencia.