Se usó la API de Cloud Translation para traducir esta página.

Crea y usa tablas

En este documento, se describe cómo crear y usar tablas estándar (integradas) en BigQuery. Para obtener información sobre cómo crear otros tipos de tablas, consulta las siguientes páginas:

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 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.
De forma opcional, puedes leer Introducción a las tablas para comprender las limitaciones, las cuotas y los precios de las tablas.

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 puede contener lo siguiente:

Contiene caracteres con un total de hasta 1,024 bytes UTF-8.
Caracteres Unicode en la categoría L (letra), M (marca), N (número), Pc (conector, incluido el guion bajo), Pd (raya) y Zs (espacio) Para obtener más información, consulta la Categoría general.

A continuación, se muestran todos los ejemplos de nombres de tabla válidos: table 01, ग्राहक, 00_お客様y étudiant-01.

Advertencias:

Los nombres de tablas distinguen entre mayúsculas y minúsculas de forma predeterminada. mytable y MyTable pueden coexistir en el mismo conjunto de datos, a menos que sean parte de un conjunto de datos con la distinción entre mayúsculas y minúsculas desactivada.
Algunos nombres de tablas y prefijos de nombres de tablas están reservados. Si recibes un error que indica que el nombre o prefijo de la tabla está reservado, selecciona un nombre diferente y vuelve a intentarlo.
Si incluyes múltiples operadores de punto (.) en una secuencia, los operadores duplicados se quitan de forma implícita.

Por ejemplo, esto: project_name....dataset_name..table_name

Se convierte en esto: project_name.dataset_name.table_name

Crear tablas

Puedes crear una tabla en BigQuery de las siguientes maneras:

De forma manual, con la consola de Google Cloud o el comando bq mk de la herramienta de línea de comandos de bq.
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.
Mediante una declaración de lenguaje de definición de datos (DDL) CREATE TABLE

Permisos necesarios

Para crear una tabla, necesitas los siguientes permisos de IAM:

bigquery.tables.create
bigquery.tables.updateData
bigquery.jobs.create

Además, es posible que necesites el permiso bigquery.tables.getData para acceder a los datos que escribas en la tabla.

Cada uno de los siguientes roles predefinidos de IAM incluye los permisos que necesitas para crear una tabla:

roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin (incluye el permiso bigquery.jobs.create)
roles/bigquery.user (incluye el permiso bigquery.jobs.create)
roles/bigquery.jobUser (incluye el permiso bigquery.jobs.create)

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

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

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

Puedes crear una tabla vacía con una definición de esquema de las siguientes maneras:

Ingresa el esquema con la consola de Google Cloud.
Proporcionar el esquema intercalado mediante la herramienta de línea de comandos de bq.
Envía un archivo de esquema JSON con la herramienta de línea de comandos de bq.
Proporciona el esquema en un recurso de tabla cuando llames al método tables.insert de las APIs.

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

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

Ir a BigQuery
En el panel Explorador, expande tu proyecto y, luego, elige un conjunto de datos.
En la sección Información del conjunto de datos, haz clic en Crear tabla.
En el panel Crear tabla, especifica los siguientes detalles:

En la sección Fuente, selecciona Tabla vacía en la lista Crear tabla desde.
En la sección Destino, especifica los siguientes detalles:
1. En Conjunto de datos, elige el conjunto de datos en el que deseas crear la tabla.
2. En el campo Tabla, escribe el nombre de la tabla que deseas crear.
3. Verifica que el campo Tipo de tabla esté configurado como Tabla nativa.
En la sección Esquema, ingresa la definición del esquema. Puedes ingresar la información del esquema de forma manual mediante uno de los siguientes métodos:
- Opción 1: Haz clic en Editar como texto y pega el esquema con el formato de un array JSON. Cuando usas un array JSON, generas el esquema mediante el mismo proceso que se usa para crear un archivo de esquema JSON. Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando:
```
    bq show --format=prettyjson dataset.table
    
```
- Opción 2: Haz clic en Agregar campo y, luego, ingresa el esquema de la tabla. Especifica el Nombre, el Tipo y el Modo de cada campo.
Opcional: Especifica Configuración de particiones y clústeres. Para obtener más información, consulta Crea tablas particionadas y Crea y usa tablas agrupadas en clústeres.
Opcional: En la sección Opciones avanzadas, si deseas usar una clave de encriptación administrada por el cliente, selecciona la opción Usar una clave de encriptación administrada por el cliente (CMEK). De forma predeterminada, BigQuery encripta contenido de clientes almacenado en reposo mediante una clave que es propiedad de Google y está administrada por Google.
Haga clic en Create table.

SQL

En el siguiente ejemplo, se crea una tabla con el nombre newtable que vence el 1 de enero de 2023.

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

Ir a BigQuery

En el editor de consultas, escribe la siguiente sentencia:

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 '2023-01-01 00:00:00 UTC',
    description = 'a table that expires in 2023',
    labels = [('org_unit', 'development')]);

Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Usa el comando bq 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. Para obtener una lista completa de los parámetros, consulta la referencia bq mk --table. Entre los parámetros opcionales, se incluyen los siguientes:
- --expiration
- --description
- --time_partitioning_field
- --time_partitioning_type
- --range_partitioning
- --clustering_fields
- --destination_kms_key
- --label
--time_partitioning_field, --time_partitioning_type, --range_partitioning, --clustering_fields y --destination_kms_key no se demuestran aquí. Consulta los siguientes vínculos para obtener más información sobre estos parámetros opcionales:
- Para obtener más información sobre --time_partitioning_field, --time_partitioning_type y --range_partitioning, consulta tablas particionadas.
- Para obtener más información sobre --clustering_fields, consulta tablas agrupadas en clústeres.
- 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_1:value_1 \
--label=key_2:value_2 \
--add_tags=key_3:value_3[,...] \
project_id:dataset.table \
schema
```
Reemplaza lo siguiente:
- integer es el ciclo de vida predeterminado (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_1:value_1 y key_2:value_2 son pares clave-valor que especifican etiquetas.
- key_3:value_3 son pares clave-valor que especifican etiquetas. Agrega varias etiquetas bajo la misma marca con comas entre pares clave-valor.
- project_id es el ID del proyecto.
- dataset es un conjunto de datos en tu proyecto.
- table es el nombre de la tabla que crearás.
- schema es una definición de esquema intercalado en el formato field:data_type,field:data_type o la ruta al archivo de esquema JSON en tu máquina local.
Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo RECORD (STRUCT) ni una descripción de la columna, y no 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.

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

Terraform

Usa el recurso google_bigquery_table.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Crear una tabla

En el siguiente ejemplo, se crea una tabla llamada mytable:

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

Crea una tabla y otórgale acceso

En el siguiente ejemplo, se crea una tabla llamada mytable y, luego, se usa el recurso google_bigquery_table_iam_policy para otorgarle acceso. Sigue este paso solo si deseas otorgar acceso a la tabla a las principales que no tienen acceso al conjunto de datos en el que reside la tabla.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:raha@altostrat.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.default.policy_data
}

Crea una tabla con una clave de encriptación administrada por el cliente

En el siguiente ejemplo, se crea una tabla llamada mytable y también usa los recursos google_kms_crypto_key y google_kms_key_ring para especificar una clave de Cloud Key Management Service para la tabla. Debes habilitar la API de Cloud Key Management Service antes de ejecutar este ejemplo.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

Para aplicar tu configuración de Terraform en un proyecto de Google Cloud, completa los pasos de las siguientes secciones.

Prepara Cloud Shell

Inicia Cloud Shell
Establece el proyecto de Google Cloud predeterminado en el que deseas aplicar tus configuraciones de Terraform.

Solo necesitas ejecutar este comando una vez por proyecto y puedes ejecutarlo en cualquier directorio.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Las variables de entorno se anulan si configuras valores explícitos en el archivo de configuración de Terraform.

Prepara el directorio

Cada archivo de configuración de Terraform debe tener su propio directorio (también llamado módulo raíz).

En Cloud Shell, crea un directorio y un archivo nuevo dentro de ese directorio. El nombre del archivo debe tener la extensión .tf, por ejemplo, main.tf. En este instructivo, el archivo se denomina main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Si sigues un instructivo, puedes copiar el código de muestra en cada sección o paso.

Copia el código de muestra en el main.tf recién creado.

De manera opcional, copia el código de GitHub. Esto se recomienda cuando el fragmento de Terraform es parte de una solución de extremo a extremo.
Revisa y modifica los parámetros de muestra que se aplicarán a tu entorno.
Guarda los cambios.
Inicializa Terraform. Solo debes hacerlo una vez por directorio.
```
terraform init
```
De manera opcional, incluye la opción -upgrade para usar la última versión del proveedor de Google:
```
terraform init -upgrade
```

Aplica los cambios

Revisa la configuración y verifica que los recursos que creará o actualizará Terraform coincidan con tus expectativas:
```
terraform plan
```
Corrige la configuración según sea necesario.
Para aplicar la configuración de Terraform, ejecuta el siguiente comando y, luego, escribe yes cuando se te solicite:
```
terraform apply
```
Espera hasta que Terraform muestre el mensaje “¡Aplicación completa!”.
Abre tu proyecto de Google Cloud para ver los resultados. En la consola de Google Cloud, navega a tus recursos en la IU para asegurarte de que Terraform los haya creado o actualizado.

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 C# incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


using Google.Cloud.BigQuery.V2;

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 incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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)
	}
	defer client.Close()

	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 para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

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

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Node.js

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

// 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 para PHP incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 este ejemplo, sigue las instrucciones de configuración para Python incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

from google.cloud import bigquery

# 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 para Ruby incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 vacía sin una definición de esquema

Java

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a table without schema
public class CreateTableWithoutSchema {

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

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

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(Schema.of());
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

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

Abre la página BigQuery en la consola de Google Cloud.

Ir a la página de BigQuery
En el panel Explorador, expande tu proyecto y elige un conjunto de datos.
Escribe una consulta de SQL válida.
Haz clic en Más y, luego, elige Opciones de consulta.
Elige la opción Set a destination table for query results (Establecer una tabla de destino para los resultados de la consulta).
En la sección Destino, elige el Conjunto de datos en el que deseas crear la tabla y, luego, elige un ID de la tabla.
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.
Opcional: En Ubicación de los datos, elige tu ubicación.
Para actualizar la configuración de la consulta, haz clic en Guardar.
Haz clic en Ejecutar. 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 la consulta, puedes hacer clic en el botón Guardar los resultados encima del editor para copiar la tabla de resultados almacenados en caché en una tabla permanente.

SQL

En el siguiente ejemplo, se usa la declaración CREATE TABLE para crear la tabla trips a partir de los datos de la tabla bikeshare_trips pública:

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

Ir a BigQuery

En el editor de consultas, escribe la siguiente sentencia:

CREATE TABLE mydataset.trips AS (
  SELECT
    bike_id,
    start_time,
    duration_minutes
  FROM
    bigquery-public-data.austin_bikeshare.bikeshare_trips
);

Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

Para obtener más información, consulta Crea una tabla nueva a partir de una tabla existente.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Escribe 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 GoogleSQL. 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'
```
  Reemplaza 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 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 la consulta.
- table es el nombre de la tabla en la que escribes los resultados de las consultas.
- query es una consulta en la sintaxis de GoogleSQL.
  
  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:
  
  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.
  
  Escribe 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'
```
  Escribe el comando siguiente para 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. 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'
```
  Escribe 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_table para agregar los resultados de las consultas a la tabla de destino.
```
bq query \
--append_table \
--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, haz 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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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)
	}
	defer client.Close()

	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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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.

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

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

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

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \n" + e.toString());
    }
  }
}

Node.js

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

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

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

Python

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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.

from google.cloud import bigquery

# 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 hace referencia a una fuente de datos externa

Una fuente de datos externa es una fuente de datos que puedes consultar directamente desde BigQuery, aunque los datos no estén almacenados en BigQuery. Por ejemplo, es posible que tengas datos en una base de datos diferente de Google Cloud, en archivos en Cloud Storage o en otro producto en la nube que desees analizar en BigQuery, pero no lo hagas. Prepárate para migrar.

Para obtener más información, consulta Introducción a las fuentes de datos externas.

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

Para configurar el acceso a las tablas y vistas, puedes otorgar un rol de IAM a una entidad en los siguientes niveles, ordenados según el rango de recursos permitidos (de mayor a menor):

un nivel alto en la jerarquía de recursos de Google Cloud, como el nivel de proyecto, organización o carpeta
el nivel del conjunto de datos
el nivel de la tabla o la vista

También puedes restringir el acceso a los datos dentro de las tablas con los siguientes métodos:

El acceso con cualquier recurso protegido por IAM es aditivo. Por ejemplo, si una entidad no tiene acceso en un nivel alto, como un proyecto, podrías otorgar acceso a la entidad a nivel del conjunto de datos. Luego, la entidad tendrá acceso a las tablas y vistas del conjunto de datos. Del mismo modo, si la entidad no tiene acceso en el nivel alto o en el de conjunto de datos, puedes otorgar acceso a la entidad a nivel de tabla o de vista.

Si otorgas funciones de 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, la entidad tiene acceso a un amplio conjunto de recursos. Por ejemplo, cuando se otorga una función a una entidad en el nivel de proyecto, se le brindan permisos que se aplican a todos los conjuntos de datos del proyecto.

Si 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, incluso si la entidad no tiene acceso a un nivel superior. Para obtener información sobre la configuración de los controles de acceso a nivel de conjunto de datos, consulta Controla el acceso a los conjuntos de datos.

Cuando se otorga una función a nivel de tabla o vista, se especifican las operaciones que una entidad puede realizar en las tablas y vistas específicas, incluso si la entidad no tiene acceso a un nivel superior. Para obtener información sobre la configuración de los controles de acceso a nivel de tabla, consulta Controla el acceso a las tablas y vistas.

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

No puedes establecer un permiso de denegación en ningún recurso protegido por IAM.

Para obtener más información sobre los roles y los permisos, consulta Comprende los roles en la documentación de IAM y los roles y permisos de IAM de BigQuery.

Obtén información sobre las tablas

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

Usa la consola de Google Cloud
Usa el comando bq show de la herramienta de línea de comandos de bq.
Mediante una llamada al método de la API tables.get
Usa bibliotecas cliente.
Consulta la vista INFORMATION_SCHEMA.VIEWS.

Permisos necesarios

Como mínimo, para obtener información sobre las tablas, debes tener permisos bigquery.tables.get. En las siguientes funciones predefinidas de IAM, se 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 los roles y permisos de IAM en BigQuery, consulta Control de acceso.

Obtén información de tablas

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

Console

En el panel de navegación, en la sección Recursos, expande tu proyecto y, luego, selecciona un conjunto de datos.
Haz clic en el nombre del conjunto de datos para expandirlo. Aparecerán las tablas y vistas del conjunto de datos.
Haz clic en el nombre de la tabla.
En el panel Detalles, haz clic en Detalles para mostrar la descripción y la información de la tabla.
De manera opcional, cambia a la pestaña Esquema para ver la definición del esquema de la tabla.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Emite 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. Se puede usar la marca --format 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
```
Donde:
- project_id es el ID del proyecto.
- dataset es el nombre del conjunto de datos.
- table es el nombre de la tabla.
Por ejemplo:

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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)
	}
	defer client.Close()

	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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

public class GetTable {

  public static void runGetTable() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery_public_data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    getTable(projectId, datasetName, tableName);
  }

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

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);
      System.out.println("Table info: " + table.getDescription());
    } catch (BigQueryException e) {
      System.out.println("Table not retrieved. \n" + e.toString());
    }
  }
}

Node.js

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


from google.cloud import bigquery

# 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 de tablas mediante `INFORMATION_SCHEMA`

INFORMATION_SCHEMA es una serie de vistas que proporcionan acceso a metadatos sobre conjuntos de datos, rutinas, tablas, vistas, trabajos, reservas y datos de transmisión.

Puedes consultar las siguientes vistas para obtener información de la tabla:

Usa las vistas INFORMATION_SCHEMA.TABLES y INFORMATION_SCHEMA.TABLE_OPTIONS para recuperar metadatos sobre las tablas y las vistas en un proyecto.
Usa las vistas INFORMATION_SCHEMA.COLUMNS y INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para recuperar metadatos sobre las columnas (campos) en una tabla.
Usa las vistas INFORMATION_SCHEMA.TABLE_STORAGE para recuperar metadatos sobre el uso del almacenamiento histórico y actual 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.

Vista `TABLES`

Cuando consultas la vista INFORMATION_SCHEMA.TABLES, los resultados contienen una fila por cada tabla o vista de un conjunto de datos. Para obtener información detallada sobre las vistas, consulta la vista INFORMATION_SCHEMA.VIEWS en su lugar.

La vista INFORMATION_SCHEMA.TABLES tiene el siguiente esquema:

Nombre de la columna	Tipo de datos	Valor
`table_catalog`	`STRING`	El ID del proyecto que contiene el conjunto de datos.
`table_schema`	`STRING`	El nombre del conjunto de datos que contiene la tabla o la vista, también denominado `datasetId`.
`table_name`	`STRING`	El nombre de la tabla o la vista, también denominado `tableId`.
`table_type`	`STRING`	El tipo de tabla, que es una de las siguientes opciones: `BASE TABLE`: Una tabla estándar. `CLONE`: Una clonación de tabla `SNAPSHOT`: Una instantánea de la tabla `VIEW`: Una vista `MATERIALIZED VIEW`: Una vista materializada o una réplica de vista materializada `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`
`is_change_history_enabled`	`STRING`	`YES` o `NO`, según si el historial de cambios está habilitado
`creation_time`	`TIMESTAMP`	La fecha y hora de creación de la tabla
`base_table_catalog`	`STRING`	Para las clonaciones de tabla y las instantáneas de tabla, es el proyecto de la tabla base. Solo se aplica a las tablas que tienen `table_type` configurado como `CLONE` o `SNAPSHOT`.
`base_table_schema`	`STRING`	Para las clonaciones de tabla y las instantáneas de tabla, es el conjunto de datos de la tabla base. Solo se aplica a las tablas que tienen `table_type` configurado como `CLONE` o `SNAPSHOT`.
`base_table_name`	`STRING`	Para las clonaciones de tabla y las instantáneas de tabla, es el nombre de la tabla base. Solo se aplica a las tablas que tienen `table_type` configurado como `CLONE` o `SNAPSHOT`.
`snapshot_time_ms`	`TIMESTAMP`	Para las clonaciones de tabla y las instantáneas de tabla, la hora en que se clonó o la instantánea se ejecutó en la tabla base para crear esta tabla. Si se usó el viaje en el tiempo, este campo contiene la marca de tiempo del viaje en el tiempo. De lo contrario, el campo `snapshot_time_ms` es igual al campo `creation_time`. Solo se aplica a las tablas que tienen `table_type` configurado como `CLONE` o `SNAPSHOT`.
`replica_source_catalog`	`STRING`	Para las réplicas de vista materializada, es el proyecto de la vista materializada base.
`replica_source_schema`	`STRING`	Para las réplicas de vista materializada, es el conjunto de datos de la vista materializada base.
`replica_source_name`	`STRING`	Para las réplicas de vista materializada, es el nombre de la vista materializada base.
`replication_status`	`STRING`	Para las réplicas de vista materializada, el estado de la replicación de la vista materializada base a la réplica de vista materializada; uno de los siguientes: `REPLICATION_STATUS_UNSPECIFIED` `ACTIVE`: La replicación está activa sin errores `SOURCE_DELETED`: La vista materializada de origen se borró `PERMISSION_DENIED`: La vista materializada de origen no se ha autorizado en el conjunto de datos que contiene las tablas de BigLake de Amazon S3 de origen que se usan en la consulta que creó la vista materializada. `UNSUPPORTED_CONFIGURATION`: Hay un problema con los requisitos previos de la réplica que no sean la autorización de vista materializada de origen.
`replication_error`	`STRING`	Si `replication_status` indica un problema de replicación para una réplica de vista materializada, `replication_error` proporciona más detalles sobre el problema.
`ddl`	`STRING`	La declaración DDL que se puede usar para volver a crear la tabla, como `CREATE TABLE` o `CREATE VIEW`.
`default_collation_name`	`STRING`	El nombre de la especificación de la intercalación predeterminada, si existe; en caso contrario, `NULL`.
`upsert_stream_apply_watermark`	`TIMESTAMP`	En el caso de las tablas que usan la captura de datos modificados (CDC), la hora en que se aplicaron las modificaciones de fila por última vez. Para obtener más información, consulta Supervisa el progreso de la operación de inserción y actualización de tablas.

Ejemplos

Ejemplo 1:

En el ejemplo siguiente, se recuperan los metadatos de todas las tablas en el conjunto de datos llamado mydataset. Los metadatos que se muestran corresponden a todos los tipos de tablas de mydataset en tu proyecto predeterminado.

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

SELECT
  table_catalog, table_schema, table_name, table_type,
  is_insertable_into, creation_time, ddl
FROM
  mydataset.INFORMATION_SCHEMA.TABLES;

El resultado es similar al siguiente. Para facilitar la lectura, algunas columnas se excluyen del resultado.

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` |
|                |               |                |            |                    |                     | (                                           |
|                |               |                |            |                    |                     |   id INT64                                  |
|                |               |                |            |                    |                     | );                                          |
| myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1`   |
|                |               |                |            |                    |                     | AS SELECT 100 as id;                        |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+

Ejemplo 2:

En el ejemplo siguiente, se recuperan los metadatos de todas las tablas de tipo CLONE o SNAPSHOT de la vista INFORMATION_SCHEMA.TABLES. Los metadatos que se muestran corresponden a las tablas de mydataset en tu proyecto predeterminado.

  SELECT
    table_name, table_type, base_table_catalog,
    base_table_schema, base_table_name, snapshot_time_ms
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'CLONE'
  OR
    table_type = 'SNAPSHOT';

El resultado es similar al siguiente. Para facilitar la lectura, algunas columnas se excluyen del resultado.

  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | table_name   | table_type | base_table_catalog | base_table_schema | base_table_name | snapshot_time_ms    |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | items_clone  | CLONE      | myproject          | mydataset         | items           | 2018-10-31 22:40:05 |
  | orders_bk    | SNAPSHOT   | myproject          | mydataset         | orders          | 2018-11-01 08:22:39 |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+

Ejemplo 3:

En el siguiente ejemplo, se recuperan las columnas table_name y ddl de la vista INFORMATION_SCHEMA.TABLES 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, debes agregar el ID del proyecto al conjunto de datos en el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view. En este ejemplo, el valor es `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

SELECT
  table_name, ddl
FROM
  `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
WHERE
  table_name = 'population_by_zip_2010';

El resultado es similar al siguiente:

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       table_name       |                                                                                                            ddl                                                                                                             |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010`                                                                                                                                               |
|                        | (                                                                                                                                                                                                                          |
|                        |   geo_id STRING OPTIONS(description="Geo code"),                                                                                                                                                                           |
|                        |   zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"),                                                                                                                          |
|                        |   population INT64 OPTIONS(description="The total count of the population for this segment."),                                                                                                                             |
|                        |   minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."),                                                          |
|                        |   maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), |
|                        |   gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.")                                                                                                                    |
|                        | )                                                                                                                                                                                                                          |
|                        | OPTIONS(                                                                                                                                                                                                                   |
|                        |   labels=[("freebqcovid", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Vista `TABLE_OPTIONS`

Cuando consultas la vista INFORMATION_SCHEMA.TABLE_OPTIONS, los resultados contienen una fila por cada opción, por cada tabla o vista de un conjunto de datos. Para obtener información detallada sobre las vistas, consulta la vista INFORMATION_SCHEMA.VIEWS en su lugar.

La vista INFORMATION_SCHEMA.TABLE_OPTIONS tiene el siguiente esquema:

Nombre de la columna	Tipo de datos	Valor
`TABLE_CATALOG`	`STRING`	El ID del proyecto que contiene el conjunto de datos
`TABLE_SCHEMA`	`STRING`	El nombre del conjunto de datos que contiene la tabla o la vista (también denominado `datasetId`)
`TABLE_NAME`	`STRING`	El nombre de la tabla o la vista (también denominado `tableId`)
`OPTION_NAME`	`STRING`	Uno de los valores de nombre de 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`
`description`	`STRING`	Una descripción de la tabla
`enable_refresh`	`BOOL`	Indica si la actualización automática está habilitada para una vista materializada
`expiration_timestamp`	`TIMESTAMP`	La hora a la que vence esta tabla
`friendly_name`	`STRING`	El nombre descriptivo de la tabla
`kms_key_name`	`STRING`	El nombre de la clave de Cloud KMS que se usa para encriptar la tabla
`labels`	`ARRAY<STRUCT<STRING, STRING>>`	Un array de `STRUCT` que representa las etiquetas de la tabla
`partition_expiration_days`	`FLOAT64`	El ciclo de vida predeterminado de todas las particiones de una tabla particionada, expresado en días
`refresh_interval_minutes`	`FLOAT64`	Frecuencia con la que se actualiza una vista materializada
`require_partition_filter`	`BOOL`	Si las consultas sobre la tabla requieren un filtro de partición
`tags`	`ARRAY<STRUCT<STRING, STRING>>`	Etiquetas adjuntas a una tabla en una sintaxis <key, value> de espacio de nombres. Para obtener más información, consulta Etiquetas y acceso condicional.

En el caso de las tablas externas, son posibles las siguientes opciones:

Opciones
`allow_jagged_rows`	`BOOL` Si es `true`, habilita las filas a las que les faltan columnas opcionales finales. Se aplica a los datos CSV.
`allow_quoted_newlines`	`BOOL` Si es `true`, habilita las secciones de datos entrecomillados que contienen caracteres de salto de línea en el archivo. Se aplica a los datos CSV.
`bigtable_options`	`STRING` Solo es necesaria cuando se crea una tabla externa de Bigtable. Especifica el esquema de la tabla externa de Bigtable en formato JSON. Para obtener una lista de las opciones de definición de tablas de Bigtable, consulta `BigtableOptions` en la referencia de la API de REST.
`column_name_character_map`	`STRING` Define los permisos de los caracteres de nombre de columna admitidos y el comportamiento de manejo de caracteres no compatibles. La configuración predeterminada es `STRICT`, lo que significa que los caracteres no admitidos hacen que BigQuery genere errores. `V1` y `V2` reemplazan cualquier carácter no admitido por guiones bajos. Entre los valores admitidos, se incluyen los siguientes: `STRICT`. Habilita los nombres flexibles de columnas. Este es el valor predeterminado. Los trabajos de carga con caracteres no compatibles en los nombres de columna fallan con un mensaje de error. Para configurar el reemplazo de caracteres no admitidos por guiones bajos para que la tarea de carga se realice correctamente, especifica el parámetro de configuración `default_column_name_character_map`. `V1`. Los nombres de las columnas solo pueden contener caracteres de nombre de columna estándar. Los caracteres no admitidos se reemplazan por guiones bajos. Este es el comportamiento predeterminado de las tablas creadas antes de la introducción de `column_name_character_map`. `V2`. Además de los caracteres de nombre de columna estándar, también admite nombres de columnas flexibles. Los caracteres no admitidos se reemplazan por guiones bajos. Se aplica a los datos CSV y Parquet.
`compression`	`STRING` El tipo de compresión de la fuente de datos. Entre los valores admitidos, se incluyen los siguientes: `GZIP`. Si no se especifica, la fuente de datos no está comprimida. Se aplica a los datos CSV y JSON.
`decimal_target_types`	`ARRAY<STRING>` Determina cómo convertir un tipo `Decimal`. Equivale a ExternalDataConfiguration.decimal_target_types Ejemplo: `["NUMERIC", "BIGNUMERIC"]`.
`description`	`STRING` Una descripción de esta tabla.
`enable_list_inference`	`BOOL` Si es `true`, usa la inferencia de esquema específicamente para el tipo lógico de Parquet LIST. Se aplica a los datos de Parquet.
`enable_logical_types`	`BOOL` Si es `true`, convierte los tipos lógicos de Avro en sus tipos de SQL correspondientes. Para obtener más información, consulta Tipos lógicos. Se aplica a los datos de Avro.
`encoding`	`STRING` La codificación de caracteres de los datos. Los valores admitidos son los siguientes: `UTF8` (o `UTF-8`), `ISO_8859_1` (o `ISO-8859-1`). Se aplica a los datos CSV.
`enum_as_string`	`BOOL` Si es `true`, infiere el tipo lógico de Parquet ENUM como STRING en lugar de BYTES de forma predeterminada. Se aplica a los datos de Parquet.
`expiration_timestamp`	`TIMESTAMP` La hora a la que vence esta tabla. Si no se especifica, la tabla no expira. Ejemplo: `"2025-01-01 00:00:00 UTC"`.
`field_delimiter`	`STRING` El separador de campos de un archivo CSV (opcional). Se aplica a los datos CSV.
`format`	`STRING` El formato de los datos externos. Los valores admitidos para `CREATE EXTERNAL TABLE` incluyen los siguientes: `AVRO`, `CLOUD_BIGTABLE`, `CSV`, `DATASTORE_BACKUP`, `DELTA_LAKE` (vista previa), `GOOGLE_SHEETS`, `NEWLINE_DELIMITED_JSON` (o `JSON`), `ORC`, `PARQUET`. Los valores admitidos para `LOAD DATA` incluyen los siguientes: `AVRO`, `CSV`, `DELTA_LAKE` (vista previa) `NEWLINE_DELIMITED_JSON` (o `JSON`), `ORC`, `PARQUET`. El valor `JSON` es equivalente a `NEWLINE_DELIMITED_JSON`.
`hive_partition_uri_prefix`	`STRING` Prefijo común para todos los URI de origen antes de que comience la codificación de la clave de partición. Se aplica solo a las tablas externas particionadas de subárbol. Se aplica a los datos de Avro, CSV, JSON, Parquet y ORC. Ejemplo: `"gs://bucket/path"`.
`file_set_spec_type`	`STRING` Especifica cómo interpretar los URI de origen para trabajos de carga y tablas externas. Entre los valores admitidos, se incluyen los siguientes: `FILE_SYSTEM_MATCH` Expande los URI de origen enumerando los archivos del almacén de objetos. Este es el comportamiento predeterminado si FileSetSpecType no está configurado. `NEW_LINE_DELIMITED_MANIFEST` Indica que los URI proporcionados son archivos de manifiesto delimitados por líneas nuevas, con un URI por línea. Los URI comodín no son compatibles con los archivos de manifiesto y todos los archivos de datos a los que se hace referencia deben estar en el mismo bucket que el archivo de manifiesto. Por ejemplo, si tienes un URI de origen de `"gs://bucket/path/file"` y `file_set_spec_type` es `FILE_SYSTEM_MATCH`, el archivo se usa directamente como archivo de datos. Si `file_set_spec_type` es `NEW_LINE_DELIMITED_MANIFEST`, cada línea del archivo se interpreta como un URI que apunta a un archivo de datos.
`ignore_unknown_values`	`BOOL` Si es `true`, ignora los valores adicionales que no están representados en el esquema de la tabla, sin mostrar un error. Se aplica a los datos CSV y JSON.
`json_extension`	`STRING` Para los datos JSON, indica un formato de intercambio JSON en particular. Si no se especifica, BigQuery lee los datos como registros JSON genéricos. Entre los valores admitidos, se incluyen los siguientes: `GEOJSON` Datos GeoJSON delimitados por saltos de línea. Para obtener más información, consulta Crea una tabla externa a partir de un archivo GeoJSON delimitado por saltos de línea.
`max_bad_records`	`INT64` La cantidad máxima de registros erróneos que se deben ignorar cuando se leen los datos. Se aplica a los datos CSV, JSON y de Hojas de cálculo de Google.
`max_staleness`	`INTERVAL` Aplicable a las tablas de BigLake y las tablas de objetos. Especifica si las operaciones en la tabla usan los metadatos almacenados en caché y qué tan recientes deben ser los metadatos almacenados en caché para que la operación los use. Para inhabilitar el almacenamiento en caché de metadatos, especifica 0. Esta es la opción predeterminada. Para habilitar el almacenamiento en caché de metadatos, especifica un valor de intervalo literal entre 30 minutos y 7 días. Por ejemplo, especifica `INTERVAL 4 HOUR` para un intervalo de inactividad de 4 horas. Con este valor, las operaciones en la tabla usan metadatos almacenados en caché si se actualizaron en las últimas 4 horas. Si los metadatos almacenados en caché son más antiguos que eso, la operación recurre a la recuperación de metadatos desde Cloud Storage.
`null_marker`	`STRING` La string que representa los valores `NULL` en un archivo CSV. Se aplica a los datos CSV.
`object_metadata`	`STRING` Solo se requiere cuando se crea una tabla de objetos. Configura el valor de esta opción como `SIMPLE` cuando crees una tabla de objetos.
`preserve_ascii_control_characters`	`BOOL` Si es `true`, se conservan los caracteres de control ASCII incorporados que son los primeros 32 caracteres en la tabla ASCII, desde "\x00" hasta "\x1F". Se aplica a los datos CSV.
`projection_fields`	`STRING` Una lista de propiedades de entidad para cargar. Se aplica a los datos de Datastore.
`quote`	`STRING` La string que se usa para entrecomillar secciones de datos en un archivo de CSV. Si tus datos contienen caracteres de salto de línea entrecomillados, también establece la propiedad `allow_quoted_newlines` en `true`. Se aplica a los datos CSV.
`reference_file_schema_uri`	`STRING` El archivo de referencia proporcionado por el usuario con el esquema de tabla. Se aplica a los datos de Parquet/ORC/AVRO. Ejemplo: `"gs://bucket/path/reference_schema_file.parquet"`.
`require_hive_partition_filter`	`BOOL` Si es `true`, todas las búsquedas en esta tabla requieren un filtro de partición que se pueda usar para eliminar particiones cuando se leen datos. Se aplica solo a las tablas externas particionadas de subárbol. Se aplica a los datos de Avro, CSV, JSON, Parquet y ORC.
`sheet_range`	`STRING` Rango de Hojas de cálculo de Google desde el que se realiza la búsqueda. Se aplica a los datos de Hojas de cálculo de Google. Ejemplo: `"sheet1!A1:B20"`.
`skip_leading_rows`	`INT64` La cantidad de filas en la parte superior de un archivo que se deben omitir cuando se leen los datos. Se aplica a los datos CSV y de Hojas de cálculo de Google.
`uris`	En el caso de las tablas externas, incluidas las de objetos, que no son tablas de Bigtable, haz lo siguiente: `ARRAY<STRING>` Un array de URI completamente calificados para las ubicaciones de datos externas. Cada URI puede contener un carácter comodín de asterisco (``), que debe aparecer después del nombre del bucket. Cuando especificas valores `uris` que se orientan a varios archivos, todos esos archivos deben compartir un esquema compatible. En los siguientes ejemplos, se muestran valores `uris` válidos: `['gs://bucket/path1/myfile.csv']` `['gs://bucket/path1/.csv']` `['gs://bucket/path1/', 'gs://bucket/path2/file00']` En el caso de las tablas de Bigtable: `STRING` El URI que identifica la tabla de Bigtable que se usará como fuente de datos. Solo puedes especificar un URI de Bigtable. Ejemplo: `https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name` Si deseas obtener más información para crear un URI de Bigtable, consulta Cómo recuperar el URI de Bigtable.

Ejemplos

Ejemplo 1:

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

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'expiration_timestamp';

El resultado es similar al 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 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.

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

El resultado es similar al 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 contienen una fila por cada columna (campo) de una tabla.

La vista INFORMATION_SCHEMA.COLUMNS tiene el siguiente esquema:

Nombre de la columna	Tipo de datos	Valor
`TABLE_CATALOG`	`STRING`	El ID del proyecto que contiene el conjunto de datos
`TABLE_SCHEMA`	`STRING`	El nombre del conjunto de datos que contiene la tabla (también denominado `datasetId`)
`TABLE_NAME`	`STRING`	El nombre de la tabla o la vista (también denominado `tableId`)
`COLUMN_NAME`	`STRING`	El nombre de la columna
`ORDINAL_POSITION`	`INT64`	El desplazamiento (con indexación de base 1) 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 GoogleSQL 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 se trata de 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 se trata de 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`	`INT64`	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
`COLLATION_NAME`	`STRING`	El nombre de la especificación de la intercalación, si existe; de lo contrario, `NULL` si se pasa `STRING` o `ARRAY<STRING>`, la especificación de la intercalación se muestra si existe; en caso contrario, se muestra `NULL`
`COLUMN_DEFAULT`	`STRING`	El valor predeterminado de la columna, si existe; de lo contrario, el valor es `NULL`.
`ROUNDING_MODE`	`STRING`	El modo de redondeo que se usa para los valores escritos en el campo si su tipo es un `NUMERIC` o `BIGNUMERIC` con parámetros; de lo contrario, el valor es `NULL`.

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

  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';

El resultado es similar al siguiente. Para facilitar la lectura, algunas columnas se excluyen del resultado.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       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 contienen una fila por 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 ID del proyecto que contiene el conjunto de datos
`TABLE_SCHEMA`	`STRING`	El nombre del conjunto de datos que contiene la tabla (también denominado `datasetId`)
`TABLE_NAME`	`STRING`	El nombre de la tabla o la vista (también denominado `tableId`)
`COLUMN_NAME`	`STRING`	El nombre de la columna
`FIELD_PATH`	`STRING`	La ruta a una columna anidada dentro de una columna “RECORD” (o “STRUCT”)
`DATA_TYPE`	`STRING`	El tipo de datos de GoogleSQL de la columna
`DESCRIPTION`	`STRING`	La descripción de la columna
`COLLATION_NAME`	`STRING`	El nombre de la especificación de la intercalación, si existe; de lo contrario, `NULL` si se pasa un campo `STRING`, `ARRAY<STRING>` o `STRING` en `STRUCT`, la especificación de la intercalación se muestra si existe; en caso contrario, se muestra `NULL`.
`ROUNDING_MODE`	`STRING`	El modo de redondeo que se usa cuando se aplica precisión y escalamiento a valores `NUMERIC` o `BIGNUMERIC` parametrizados; de lo contrario, el valor es `NULL`.

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 conjuntos de datos públicos de BigQuery.

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

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

Para ver los metadatos de las columnas author y difference, ejecuta la siguiente consulta.

SELECT
  *
FROM
  `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
WHERE
  table_name = 'commits'
  AND (column_name = 'author' OR column_name = 'difference');

El resultado es similar al siguiente. Para facilitar la lectura, algunas columnas se excluyen del resultado.

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

Vista `TABLE_STORAGE`

Las vistas TABLE_STORAGE y TABLE_STORAGE_BY_ORGANIZATION tienen el esquema siguiente:

Nombre de la columna	Tipo de datos	Valor
`PROJECT_ID`	`STRING`	El ID del proyecto que contiene el conjunto de datos.
`PROJECT_NUMBER`	`INT64`	El número del proyecto que contiene el conjunto de datos
`TABLE_CATALOG`	`STRING`	El ID del proyecto que contiene el conjunto de datos.
`TABLE_SCHEMA`	`STRING`	El nombre del conjunto de datos que contiene la tabla o la vista materializada (también denominado `datasetId`).
`TABLE_NAME`	`STRING`	El nombre de la tabla o la vista materializada (también denominado `tableId`).
`CREATION_TIME`	`TIMESTAMP`	La hora de creación de la tabla.
`TOTAL_ROWS`	`INT64`	La cantidad total de filas en la tabla o la vista materializada
`TOTAL_PARTITIONS`	`INT64`	La cantidad de particiones presentes en la tabla o la vista materializada. Las tablas no particionadas muestran 0.
`TOTAL_LOGICAL_BYTES`	`INT64`	Cantidad total de bytes lógicos (sin comprimir) en la tabla o la vista materializada.
`ACTIVE_LOGICAL_BYTES`	`INT64`	Cantidad de bytes lógicos (sin comprimir) que tienen menos de 90 días.
`LONG_TERM_LOGICAL_BYTES`	`INT64`	Cantidad de bytes lógicos (sin comprimir) que tienen más de 90 días.
`CURRENT_PHYSICAL_BYTES`	`INT64`	Cantidad total de bytes físicos para el almacenamiento actual de la tabla en todas las particiones.
`TOTAL_PHYSICAL_BYTES`	`INT64`	Cantidad total de bytes físicos (comprimidos) que se usan para el almacenamiento, incluidos los bytes activos, a largo plazo y de viaje en el tiempo (datos borrados o modificados). No se incluyen los bytes a prueba de fallas (datos borrados o modificados retenidos después del período de viaje en el tiempo).
`ACTIVE_PHYSICAL_BYTES`	`INT64`	Cantidad de bytes físicos (comprimidos) con menos de 90 días, incluidos los bytes de viaje en el tiempo (datos borrados o modificados).
`LONG_TERM_PHYSICAL_BYTES`	`INT64`	Cantidad de bytes físicos (comprimidos) con más de 90 días.
`TIME_TRAVEL_PHYSICAL_BYTES`	`INT64`	Cantidad de bytes físicos (comprimidos) que usa el almacenamiento de viaje en el tiempo (datos borrados o modificados).
`STORAGE_LAST_MODIFIED_TIME`	`TIMESTAMP`	La hora más reciente en que los datos se escribieron en la tabla.
`DELETED`	`BOOLEAN`	Indica si la tabla se borró o no.
`TABLE_TYPE`	`STRING`	El tipo de tabla. Por ejemplo, `EXTERNAL` o `BASE TABLE`.
`FAIL_SAFE_PHYSICAL_BYTES`	`INT64`	Cantidad de bytes físicos (comprimidos) que usa el almacenamiento seguro ante fallas (datos borrados o modificados)
`LAST_METADATA_INDEX_REFRESH_TIME`	`TIMESTAMP`	La última hora de actualización del índice de metadatos de la tabla.

Ejemplos

Ejemplo 1:

En el siguiente ejemplo, se muestra el total de bytes lógicos facturados para el proyecto actual.

SELECT
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

El resultado es similar al siguiente:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+

Ejemplo 2:

En el siguiente ejemplo, se muestra cómo pronosticar la diferencia de precios por conjunto de datos entre modelos de facturación lógicos y físicos para los próximos 30 días. En este ejemplo, se supone que el uso de almacenamiento futuro es constante durante los próximos 30 días desde el momento en que se ejecutó la consulta. Ten en cuenta que la previsión se limita a las tablas base, y excluye todos los demás tipos de tablas dentro de un conjunto de datos.

Los precios que se usan en las variables de precios de esta consulta son para la región us-central1. Si quieres ejecutar esta consulta para una región diferente, actualiza las variables de precios de manera adecuada. Consulta Precios de almacenamiento para obtener información sobre los precios.

Abre la página BigQuery en la consola de Google Cloud.

Ir a la página de BigQuery

Ingresa la siguiente consulta de GoogleSQL en el cuadro Editor de consultas. INFORMATION_SCHEMA requiere sintaxis de GoogleSQL. GoogleSQL es la sintaxis predeterminada en la consola de Google Cloud.

DECLARE active_logical_gib_price FLOAT64 DEFAULT 0.02;
DECLARE long_term_logical_gib_price FLOAT64 DEFAULT 0.01;
DECLARE active_physical_gib_price FLOAT64 DEFAULT 0.04;
DECLARE long_term_physical_gib_price FLOAT64 DEFAULT 0.02;

WITH
 storage_sizes AS (
   SELECT
     table_schema AS dataset_name,
     -- Logical
     SUM(IF(deleted=false, active_logical_bytes, 0)) / power(1024, 3) AS active_logical_gib,
     SUM(IF(deleted=false, long_term_logical_bytes, 0)) / power(1024, 3) AS long_term_logical_gib,
     -- Physical
     SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
     SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
     SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
     -- Restorable previously deleted physical
     SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
     SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib,
   FROM
     `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT
   WHERE total_physical_bytes + fail_safe_physical_bytes > 0
     -- Base the forecast on base tables only for highest precision results
     AND table_type  = 'BASE TABLE'
     GROUP BY 1
 )
SELECT
  dataset_name,
  -- Logical
  ROUND(active_logical_gib, 2) AS active_logical_gib,
  ROUND(long_term_logical_gib, 2) AS long_term_logical_gib,
  -- Physical
  ROUND(active_physical_gib, 2) AS active_physical_gib,
  ROUND(long_term_physical_gib, 2) AS long_term_physical_gib,
  ROUND(time_travel_physical_gib, 2) AS time_travel_physical_gib,
  ROUND(fail_safe_physical_gib, 2) AS fail_safe_physical_gib,
  -- Compression ratio
  ROUND(SAFE_DIVIDE(active_logical_gib, active_no_tt_physical_gib), 2) AS active_compression_ratio,
  ROUND(SAFE_DIVIDE(long_term_logical_gib, long_term_physical_gib), 2) AS long_term_compression_ratio,
  -- Forecast costs logical
  ROUND(active_logical_gib * active_logical_gib_price, 2) AS forecast_active_logical_cost,
  ROUND(long_term_logical_gib * long_term_logical_gib_price, 2) AS forecast_long_term_logical_cost,
  -- Forecast costs physical
  ROUND((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price, 2) AS forecast_active_physical_cost,
  ROUND(long_term_physical_gib * long_term_physical_gib_price, 2) AS forecast_long_term_physical_cost,
  -- Forecast costs total
  ROUND(((active_logical_gib * active_logical_gib_price) + (long_term_logical_gib * long_term_logical_gib_price)) -
     (((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price) + (long_term_physical_gib * long_term_physical_gib_price)), 2) AS forecast_total_cost_difference
FROM
  storage_sizes
ORDER BY
  (forecast_active_logical_cost + forecast_active_physical_cost) DESC;

Haz clic en Ejecutar.

El resultado es similar al siguiente:

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset_name | active_logical_gib | long_term_logical_gib | active_physical_gib | long_term_physical_gib | active_compression_ratio | long_term_compression_ratio | forecast_active_logical_cost | forecaset_long_term_logical_cost | forecast_active_physical_cost | forecast_long_term_physical_cost | forecast_total_cost_difference |
+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset1     |               10.0 |                  10.0 |                 1.0 |                    1.0 |                     10.0 |                        10.0 |                          0.2 |                              0.1 |                          0.04 |                             0.02 |                           0.24 |

Enumera tablas en un conjunto de datos

Puedes enumerar tablas en conjuntos de datos de las siguientes maneras:

Usa la consola de Google Cloud
Usa el comando bq ls de la herramienta de línea de comandos de bq.
Mediante una llamada al método de la API tables.list
Usa las bibliotecas cliente.

Permisos necesarios

Como mínimo, para enumerar las tablas en un conjunto de datos, debes tener permisos bigquery.tables.list. En las siguientes funciones predefinidas de IAM, se 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 los roles y permisos de IAM en BigQuery, consulta Control de acceso.

Mostrar tablas

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

Console

En la consola de Google Cloud, 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.
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.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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 siguiente formato: 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
```
Donde:
- integer es un número entero que representa la cantidad de tablas que se deben 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. 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#

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Table;

public class ListTables {

  public static void runListTables() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    listTables(projectId, datasetName);
  }

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

      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
      tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));

      System.out.println("Tables listed successfully.");
    } catch (BigQueryException e) {
      System.out.println("Tables were not listed. Error occurred: " + e.toString());
    }
  }
}

Node.js

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


from google.cloud import bigquery

# 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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Seguridad de las tablas

Para controlar el acceso a las tablas en BigQuery, consulta Introducción a los controles de acceso a tablas.

¿Qué sigue?

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 Administra datos de tablas.
Si quieres obtener más información acerca de 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 INFORMATION_SCHEMA de BigQuery.

Pruébalo tú mismo

Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de BigQuery en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar BigQuery gratis

Crea y usa tablas

Antes de comenzar

Nombres de las tablas

Crear tablas

Permisos necesarios

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

Console

SQL

bq

Terraform

Prepara Cloud Shell

Prepara el directorio

Aplica los cambios

API

C#

Go

Java

Node.js

PHP

Python

Ruby

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

Java

Crea una tabla a partir de un resultado de consulta.

Console

SQL

bq

API

Go

Java

Node.js

Python

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

Crea una tabla cuando cargas datos

Controla el acceso a las tablas

Obtén información sobre las tablas

Permisos necesarios

Obtén información de tablas

Console

bq

API

Go

Java

Node.js

PHP

Python

Obtén información de tablas mediante INFORMATION_SCHEMA

Vista TABLES

Ejemplos

Ejemplo 1:

Ejemplo 2:

Ejemplo 3:

Vista TABLE_OPTIONS

Tabla de opciones

Ejemplos

Ejemplo 1:

Ejemplo 2:

Vista COLUMNS

Ejemplos

Vista COLUMN_FIELD_PATHS

Ejemplos

Vista TABLE_STORAGE

Ejemplos

Ejemplo 1:

Ejemplo 2:

Enumera tablas en un conjunto de datos

Permisos necesarios

Mostrar tablas

Console

bq

API

C#

Go

Java

Node.js

PHP

Python

Ruby

Seguridad de las tablas

¿Qué sigue?

Obtén información de tablas mediante `INFORMATION_SCHEMA`

Vista `TABLES`

Vista `TABLE_OPTIONS`

Vista `COLUMNS`

Vista `COLUMN_FIELD_PATHS`

Vista `TABLE_STORAGE`