Crea y usa tablas

En este documento, se describe el proceso para crear y usar tablas estándar o “nativas” en BigQuery. Para obtener información sobre cómo crear otros tipos de tablas, consulta las siguientes páginas:

• Cómo crear y usar tablas particionadas por tiempo de transferencia
• Crea y usa tablas particionadas por una columna DATE o TIMESTAMP
• Crea y usa tablas agrupadas

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

Antes de comenzar

Antes de crear una tabla en BigQuery, primero haz lo siguiente:

• Configura un proyecto con una guía de introducción de BigQuery.
• Crea un conjunto de datos de BigQuery.

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.
• Cloud Console 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, la API o las bibliotecas cliente, todas las tablas de origen deben tener esquemas idénticos.
• Solo puedes borrar una tabla a la vez con Cloud Console, la IU web clásica de BigQuery, la herramienta de línea de comandos, la API o las bibliotecas cliente.
• 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, su enumeración se vuelve más lento. El rendimiento de la enumeración se ve afectado ya sea que uses una llamada a la API o la IU web clásica de BigQuery. En la actualidad, la IU web de BigQuery en Cloud Console te permite mostrar solo 50,000 tablas por conjunto de datos.

  Si quieres mejorar el rendimiento de la IU web clásica de BigQuery, puedes usar el parámetro ?minimal para limitar a 30,000 la cantidad de tablas que se muestran por proyecto. El parámetro se agrega a la URL de la IU web clásica de BigQuery con el formato siguiente: https://bigquery.cloud.google.com/queries/project_id?minimal.

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 o guiones bajos

Crea una tabla

Puedes crear una tabla en BigQuery de las siguientes maneras:

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

Permisos necesarios

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

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

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

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

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

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

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

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

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

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 mediante Cloud Console o la IU web clásica de BigQuery
• 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 llames al método tables.insert de la API

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

Después de crear la tabla, puedes cargarle datos o propagar contenidos en ella mediante la escritura de resultados de consulta.

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

Console

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

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 (Create table).

   

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

5. En la página Crear tabla, en la sección Destino (Destination), realiza lo siguiente:

   • En Nombre del conjunto de datos (Dataset name), selecciona el conjunto de datos que corresponda.

     

   • En el campo Nombre de tabla, ingresa el nombre de la tabla que quieres crear en BigQuery.

   • Verifica que Tipo de tabla (Table type) esté establecido en Tabla nativa (Native table).

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.

       Nota: Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando: bq show --format=prettyjson dataset.table.

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

7. En Configuración de partición y agrupamiento en clústeres, deja los valores predeterminados: No partitioning.

8. En la sección Opciones avanzadas, en Encriptación, deja el valor predeterminado: Google-managed key. De manera predeterminada, BigQuery encripta contenido de cliente almacenado en reposo.

9. Haz clic en Crear tabla.

Nota: Cuando se crea una tabla vacía con Cloud Console, no puedes agregar una etiqueta, descripción o fecha de vencimiento. Puedes agregar estas propiedades opcionales cuando creas una tabla mediante la CLI o la API. Después de crear una tabla en Cloud Console, puedes agregar un vencimiento, una descripción y etiquetas.

DDL

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

Obtén más información sobre cómo usar instrucciones del lenguaje de definición de datos.

Para crear una tabla en Cloud Console con una declaración DDL, haz lo siguiente:

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

2. Haz clic en Redactar consulta nueva.

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

   En la consulta siguiente, se crea una tabla con el nombre newtable que vence el 1 de enero de 2020. La descripción de la tabla es “una tabla que vence en 2020” y la etiqueta de la tabla es org_unit:development.

    CREATE TABLE mydataset.newtable
    (
      x INT64 OPTIONS(description="An optional INTEGER field"),
      y STRUCT<
        a ARRAY<STRING> OPTIONS(description="A repeated STRING field"),
        b BOOL
      >
    )
    OPTIONS(
      expiration_timestamp=TIMESTAMP "2020-01-01 00:00:00 UTC",
      description="a table that expires in 2020",
      labels=[("org_unit", "development")]
    )

4. Haz clic en Más (More) y selecciona Configuración de consulta (Query settings) (opcional).

5. En Ubicación de procesamiento (Processing Location), haz clic en Selección automática (Auto-select) y elige la ubicación de tus datos (opcional). Si dejas la ubicación de procesamiento como no especificada, esta se detecta de forma automática.

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

IU clásica

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

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

3. 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 (Table type) esté establecido en Tabla nativa (Native table).

4. 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 de JSON:

       

       Nota: Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando: bq show --schema --format=prettyjson project_id:dataset.table.

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

       

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

   • Tipo de partición: None
   • Campo de partición: no debe estar disponible
   • Requerir filtro de partición: no debe estar disponible
   • Campos de agrupamiento en clústeres: no debe estar disponible
   • Encriptación de destino: Default. De forma predeterminada, BigQuery encripta el contenido del cliente almacenado en reposo con una clave administrada por Google.

6. Haz clic en Crear tabla.

Nota: Cuando creas una tabla vacía con la IU web, no puedes agregar una etiqueta, una descripción o un vencimiento. Puedes agregar estas propiedades opcionales cuando creas una tabla mediante la CLI o la API. Después de crear una tabla con la IU web de BigQuery, puedes agregar un vencimiento, una descripción y etiquetas.

CLI

Usa el comando mk con la marca --table o -t. Puedes suministrar la información del esquema de la tabla de forma intercalada o con un archivo de esquema JSON. Entre los parámetros opcionales se incluyen los siguientes:

• --expiration
• --description
• --time_partitioning_type
• --destination_kms_key
• --label.

--time_partitioning_type y --destination_kms_key no se demuestran aquí. Para obtener más información sobre --time_partitioning_type, consulta tabla particionada por tiempo de transferencia o tablas particionadas. Para obtener más información sobre --destination_kms_key, consulta las claves de encriptación administradas por el cliente.

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.

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 la duración predeterminada (en segundos) de la tabla. El valor mínimo es 3,600 segundos (una hora). La hora de vencimiento se evalúa según la hora UTC actual más el 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 múltiples 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 quieres crear.
• schema es una definición del esquema intercalado en el formato field:data_type,field:data_type o la ruta al archivo del esquema JSON de 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 la columna, ni tampoco puedes especificar el modo de la columna. Todos los modos están establecidos como NULLABLE de forma predeterminada. Para incluir descripciones, modos y tipos de RECORD, proporciona un archivo de esquema JSON en su lugar.

Por ejemplo:

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 como This is my table y la etiqueta como organization:development. El comando usa el acceso directo -t en lugar de --table. El esquema está especificado de forma intercalada como: qtr:STRING,sales:FLOAT,year:STRING.

bq mk \
-t \
--expiration 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 como This is my table y la etiqueta como organization:development. La ruta al archivo del 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 como This is my table y la etiqueta como organization:development. La ruta al archivo del 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

Realiza una llamada al método tables.insert con un recurso de tabla definido.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.

Ver en GitHubComentarios

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 de Go incluidas en la Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"time"

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

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

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

	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
	}
	return nil
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java incluidas en Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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 esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran 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 BigQuery para Node.js.

Ver en GitHubComentarios

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

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

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

  // 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 de PHP incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

Ver en GitHubComentarios

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 de Python que se incluyen en la Guía de inicio rápido de BigQuery: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Ver en GitHubComentarios

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

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

Ver en GitHub Comentarios

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.

Console

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

   Ir a Cloud Console

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

3. Si el editor de consultas está oculto, haz clic en Mostrar editor, en la parte superior derecha de la ventana.

4. Ingresa una consulta de SQL válida en el área de texto del Editor de consultas.

5. Haz clic en More (Más) debajo del editor y selecciona Query settings (Configuración de consulta).

   

6. Marca la casilla Establecer una tabla de destino para los resultados de la consulta (Set a destination table for query results).

   

7. En la sección Destino (Destination), selecciona el Nombre del proyecto y el Nombre del conjunto de datos adecuados en los que se creará la tabla, y elige un Nombre de tabla.

8. En la sección Preferencia de escritura para la tabla de destino, elige una de las siguientes opciones:

   • Escribir si está vacía: escribe los resultados de las consultas en la tabla solo si está vacía.
   • Agregar a la tabla: Agrega los resultados de las consultas a una tabla existente.
   • Reemplazar la tabla: Se reemplaza una tabla existente que tiene el mismo nombre con los resultados de las consultas.

9. Opcional: En Ubicación de procesamiento, haz clic en Selección automática y elige tu ubicación.

10. Haz clic en Ejecutar consulta. Esta acción crea un trabajo de consulta que escribe los resultados de las consultas en la tabla que especificaste.

Como alternativa, si te olvidas de especificar una tabla de destino antes de ejecutar tu consulta, puedes hacer clic en el botón Guardar los resultados debajo del editor para copiar la tabla de resultados almacenados en caché en una tabla permanente.

DDL

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

Para obtener más información, consulta la sección Instrucción CREATE TABLE y el ejemplo de CREATE TABLE: Crear una tabla nueva a partir de una tabla existente.

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 botón Redactar consulta.

3. Ingresa una consulta de SQL válida en el área de texto Consulta nueva.

4. Haz clic en Mostrar opciones.

5. En la sección Tabla de destino, haz clic en Seleccionar tabla.

6. En el cuadro de diálogo Seleccionar tabla de destino, haz lo siguiente:

   1. En Proyecto, elige un proyecto para almacenar el conjunto de datos y la tabla.

   2. En el Conjunto de datos, elige el conjunto de datos para almacenar la tabla.

   3. En el campo ID de 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 Aceptar.

7. En la sección Tabla de destino, en Preferencia de escritura, elige una de las siguientes opciones:

   • Escribir si está vacía: escribe los resultados de las consultas en la tabla solo si está vacía.
   • Agregar a la tabla: Agrega los resultados de las consultas a una tabla existente.
   • Reemplazar la tabla: Se reemplaza una tabla existente que tiene el mismo nombre con los resultados de las consultas.

8. Opcional: En Ubicación de procesamiento, haz clic en Sin especificar y elige la ubicación de tus datos.

9. Haz clic en Ejecutar consulta. Esta acción crea un trabajo de consulta que escribe los resultados de las consultas en la tabla que especificaste.

Como alternativa, si te olvidas de especificar una tabla de destino antes de ejecutar tu consulta, puedes hacer clic en el botón Guardar como tabla en la ventana de resultados para copiar la tabla temporal en una 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 SQL estándar. Para escribir los resultados de las consultas en una tabla que no se encuentra en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos con el formato siguiente: project_id:dataset.

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

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

• --append_table: Si existe la tabla de destino, los resultados de las consultas se agregan a esta tabla.
• --replace: Si existe la tabla de destino, se reemplaza por los resultados de las consultas.

bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

En el ejemplo anterior, se ilustra lo siguiente:

• 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 configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
• project_id es el ID del proyecto.
• dataset es el nombre del conjunto de datos que 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 error siguiente: Error de BigQuery en la operación de consulta: error durante el procesamiento del trabajo project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

Ejemplos:

Nota: En estos ejemplos, se consulta un conjunto de datos públicos basado en EE.UU. Debido a que el conjunto de datos públicos se almacena en la ubicación multirregión de EE.UU., el conjunto de datos que contiene tu tabla de destino también debe estar en EE.UU. No puedes consultar un conjunto de datos en una ubicación y escribir los resultados en una tabla de destino en otra ubicación.

Ingresa el comando siguiente 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. Con la consulta, se recuperan datos del conjunto de datos públicos Datos de nombres de EE.UU.

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

bq 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 comando siguiente para agregar los resultados de las consultas a una tabla de destino llamada mytable en mydataset. El conjunto de datos está en my-other-project, no en tu proyecto predeterminado. En el comando, se usa la marca --append para agregar los resultados de las consultas a la tabla de destino.

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

El resultado de cada uno de estos ejemplos se verá de la manera siguiente. Para facilitar la lectura, algunos resultados se truncaron.

Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+

API

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

Si deseas controlar la ubicación de procesamiento para el trabajo de consulta, especifica la propiedad location en la sección jobReference del recurso de trabajo.

Go

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

bigquery/snippets/querying/bigquery_query_destination_table.go

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID 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: %v", err)
	}

	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)
	// Run the query and print results when the query job is completed.
	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.Fprintln(w, row)
	}
	return nil
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java incluidas en Guía de inicio rápido: usa bibliotecas cliente. Si deseas 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 con el valor TableId que desees en una QueryJobConfiguration.

Ver en GitHub

// 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 de Python que se incluyen en la Guía de inicio rápido de BigQuery: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

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

Ver en GitHub Comentarios

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

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, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

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

Una fuente de datos externa (también conocida como fuente de datos federada) se puede 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 haga referencia a la fuente de datos externa.

En BigQuery, se admiten consultas de datos de forma directa desde las aplicaciones siguientes:

• Bigtable
• Cloud Storage
• Google Drive

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:

• Consulta datos de Cloud Bigtable
• Consulta datos de Cloud Storage
• Consulta datos de Google Drive

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, consulta Introducción a la carga de datos en BigQuery.

Controla el acceso a las tablas

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 las funciones de Cloud IAM en un nivel superior en la jerarquía de recursos de Google Cloud, como el nivel de proyecto, de carpeta o de organización. Otorgar funciones en un nivel superior 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 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 los permisos, consulta los siguientes documentos:

• Comprende las funciones en la documentación de Cloud IAM
• Funciones y permisos predefinidos de BigQuery
• Controla el acceso a los conjuntos de datos

Usa tablas

Obtén información sobre las tablas

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

• Mediante Cloud Console o la IU web clásica de BigQuery
• Mediante el comando bq show de la CLI
• Mediante una llamada al método de la API tables.get
• Mediante bibliotecas cliente
• Consultas a 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 bigquery.tables.get:

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

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

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

Obtén información de las tablas

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

Console

1. En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos. Haz clic en el nombre del conjunto de datos para expandirlo. Esta acción muestra las tablas y vistas del conjunto de datos.

2. Haz clic en el nombre de la tabla.

3. Debajo del editor, haz clic en Detalles. En esta página, se muestra la descripción y la información de la tabla.

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

IU clásica

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

   

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

CLI

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

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

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

En el ejemplo anterior, se ilustra lo siguiente:

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

Ejemplos:

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

bq show --format=prettyjson mydataset.mytable

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

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

Ingresa el comando siguiente para mostrar solo la información del esquema sobre mytable en mydataset. mydataset está 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 de Go incluidas en la Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(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: %v", err)
	}

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

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java incluidas en Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran 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 BigQuery para Node.js.

Ver en GitHubComentarios

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

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

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

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

PHP

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

Ver en GitHubComentarios

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 de Python que se incluyen en la Guía de inicio rápido de BigQuery: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Ver en GitHub Comentarios

# TODO(developer): Import the client library.
# from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(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, rutinas, tablas y vistas.

Puedes consultar la vista INFORMATION_SCHEMA.TABLES y la vistaINFORMATION_SCHEMA.TABLE_OPTIONS a fin de recuperar metadatos sobre 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) en 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.

Vista TABLES

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

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 se conoce como datasetId)
TABLE_NAME	STRING	El nombre de la tabla o la vista (también se conoce como tableId)
TABLE_TYPE	STRING	El tipo de tabla: BASE TABLE: Una tabla de BigQuery. VIEW: Una vista de BigQuery EXTERNAL: Una tabla que hace referencia a una fuente de datos externa
IS_INSERTABLE_INTO	STRING	YES o NO, lo que 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

Ejemplos

Ejemplo 1:

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

mydataset contiene las tablas siguientes:

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

Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en este 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 Cloud Console.

   Ir a Cloud 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 Cloud Console.

   SELECT
    * EXCEPT(is_typed)
   FROM
    mydataset.INFORMATION_SCHEMA.TABLES
   

   Nota: En los nombres de las vistas INFORMATION_SCHEMA, se distingue entre mayúsculas y minúsculas.

3. Haz clic en Ejecutar.

Línea de comandos

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 todas las tablas en mydataset de 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 este 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 Cloud Console.

   Ir a Cloud 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 Cloud Console.

   SELECT
    * EXCEPT(is_typed)
   FROM
    mydataset.INFORMATION_SCHEMA.TABLES
   WHERE
    table_type="BASE TABLE"
   

   Nota: En los nombres de las vistas INFORMATION_SCHEMA, se distingue entre mayúsculas y minúsculas.

3. Haz clic en Ejecutar.

Línea de comandos

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

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 se conoce como datasetId)
TABLE_NAME	STRING	El nombre de la tabla o la vista (también se conoce 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 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
require_partition_filter	BOOL	Si las consultas sobre la tabla requieren un filtro de partición

Ejemplos

Ejemplo 1:

En el ejemplo siguiente, 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_SCHEMA.TABLE_OPTIONS.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en este 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 Cloud Console.

   Ir a Cloud 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 Cloud Console.

   SELECT
    *
   FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
   WHERE
    option_name="expiration_timestamp"
   

   Nota: En los nombres de las vistas INFORMATION_SCHEMA, se distingue entre mayúsculas y minúsculas.

3. Haz clic en Ejecutar.

Línea de comandos

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" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

Nota: Las tablas sin un vencimiento se excluyen de los resultados de las consultas.

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 de la opción description para encontrar tablas que contengan “test” 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 formato siguiente: `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 Cloud Console.

   Ir a Cloud 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 Cloud Console.

   SELECT
    *
   FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
   WHERE
    option_name="description" AND option_value LIKE "%test%"
   

   Nota: En los nombres de las vistas INFORMATION_SCHEMA, se distingue entre mayúsculas y minúsculas.

3. Haz clic en Ejecutar.

Línea de comandos

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.

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 se conoce como datasetId)
TABLE_NAME	STRING	El nombre de la tabla o la vista (también se conoce como 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 seudocolumna, 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 seudocolumna, 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

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

Para ejecutar la consulta, haz lo siguiente:

Console

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

   Ir a Cloud 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 Cloud 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"
   

   Nota: En los nombres de las vistas INFORMATION_SCHEMA, se distingue entre mayúsculas y minúsculas.

3. Haz clic en Ejecutar.

Línea de comandos

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 facilitar la lectura, 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 para cada columna anidada dentro de una columna RECORD (o STRUCT).

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 se conoce como datasetId)
TABLE_NAME	STRING	El nombre de la tabla o la vista (también se conoce como 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

Ejemplos

En el siguiente ejemplo, se recuperan los metadatos desde 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.

Para ejecutar la consulta, haz lo siguiente:

Console

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

   Ir a Cloud 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 Cloud 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"
   

   Nota: En los nombres de las vistas INFORMATION_SCHEMA, se distingue entre mayúsculas y minúsculas.

3. Haz clic en Ejecutar.

Línea de comandos

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 facilitar la lectura, 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 de las siguientes formas:

• Mediante Cloud Console o la IU web clásica de BigQuery
• Mediante el comando bq ls de la CLI
• Mediante una llamada al método de la API tables.list
• Mediante bibliotecas cliente

Permisos necesarios

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

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

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

Enumera tablas

Para enumerar las tablas en un conjunto de datos, haz lo siguiente:

Console

1. En Cloud Console, en el panel de navegación, haz clic en el conjunto de datos para expandirlo. Esta acción muestra las tablas y vistas del conjunto de datos.

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

IU clásica

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

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

   

CLI

Ejecuta el comando bq ls. Se puede usar la marca --format para controlar el resultado. Si enumeras tablas en un proyecto que no es el predeterminado, agrega el ID del proyecto al conjunto de datos en el formato siguiente: project_id:dataset.

Entre las marcas adicionales, se incluyen las siguientes:

• --max_results o -n: Un número entero que indica la cantidad máxima de resultados. El valor predeterminado es 50.

bq ls \
--format=pretty \
--max_results integer \
project_id:dataset

En el ejemplo anterior, se ilustra lo siguiente:

• integer es un número entero que representa la cantidad de conjuntos de datos que se van a enumerar.
• 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  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

Por ejemplo:

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

bq ls --format=pretty mydataset

Ingresa el comando siguiente para mostrar más que el resultado predeterminado de 50 tablas de mydataset. está en tu proyecto predeterminado.

bq ls --format=pretty --max_results 60 mydataset

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

bq ls --format=pretty myotherproject:mydataset

API

Para enumerar tablas con la API, realiza una llamada al método tables.list.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.

Ver en GitHubComentarios

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 de Go incluidas en la Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID 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: %v", err)
	}

	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)
	}
	return nil
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java incluidas en Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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 esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran 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 BigQuery para Node.js.

Ver en GitHubComentarios

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

async function listTables() {
  // Lists tables in 'my_dataset'.

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

  // List 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 de PHP incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

Ver en GitHubComentarios

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 de Python que se incluyen en la Guía de inicio rápido de BigQuery: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Ver en GitHubComentarios

# TODO(developer): Import the client library.
# from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

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

Ver en GitHubComentarios

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

Próximos pasos

• Para obtener más información sobre conjuntos de datos, consulta Introducción a los conjuntos de datos.
• Para obtener más información sobre el manejo de datos de tablas, consulta Cómo administrar datos de tablas.
• Para obtener más información sobre cómo especificar esquemas de tablas, consulta Especifica un esquema.
• Para obtener más información sobre cómo modificar los esquemas de las tablas, consulta Modifica esquemas de tablas.
• Si deseas obtener más información sobre cómo administrar tablas, consulta Administra tablas.
• Para ver una descripción general de INFORMATION_SCHEMA, consulta Introducción a de BigQuery.