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:

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:

  • Hasta 1,024 caracteres
  • 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.

Por ejemplo, los siguientes son nombres de tabla válidos: table 01, ग्राहक, 00_お客様, étudiant-01.

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.

Crear tablas

Puedes crear una tabla en BigQuery de las siguientes maneras:

  • De forma manual, con Cloud Console 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 una de las siguientes funciones predefinidas 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 Cloud Console.
  • Proporciona el esquema intercalado con 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 la API.

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

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

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

Console

  1. En Cloud Console, abre la página de BigQuery.

    Ir a BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

  3. Expande la opción Acciones y haz clic en Abrir.

  4. En el panel de detalles, haz clic en Crear tabla  (Create table).

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

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

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

      Seleccionar conjunto de datos

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

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

  7. En la sección Esquema, ingresa la definición del esquema.

    • Ingresa la información del esquema de forma manual de la siguiente manera:

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

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

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

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

  10. Haz clic en Crear tabla.

SQL

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

Para obtener más información, consulta cómo usar instrucciones del lenguaje de definición de datos.

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

  1. En Cloud Console, abre la página de BigQuery.

    Ir a BigQuery

  2. Haz clic en Redactar consulta nueva.

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

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

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

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

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

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

bq

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. Entre los parámetros opcionales se incluyen los siguientes:

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

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

Si creas una tabla en otro proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el formato siguiente: project_id:dataset.

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

bq mk \
--table \
--expiration integer \
--description description \
--label key_1:value_1 \
--label key_2:value_2 \
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.
  • 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, ni tampoco puedes especificar el modo de la columna. Todos los modos están establecidos como NULLABLE de forma predeterminada. Para incluir descripciones, modos y tipos de RECORD, proporciona un archivo de esquema JSON en su lugar.

Por ejemplo:

Ingresa el siguiente comando para crear una tabla con una definición de esquema intercalada. Este comando crea una tabla llamada mytable en mydataset en tu proyecto predeterminado. Se establece el vencimiento de la tabla en 3,600 segundos (1 hora), la descripción como This is my table y la etiqueta como organization:development. El comando usa el acceso directo -t en lugar de --table. El esquema está especificado de forma intercalada como: qtr:STRING,sales:FLOAT,year:STRING.

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

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

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

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

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

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

API

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

C#

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


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

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

Go

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

import (
	"context"
	"fmt"
	"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. 

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 Node.js de BigQuery. 

// 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 que se encuentran en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de BigQuery. 

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

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

from google.cloud import bigquery

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

# TODO(developer): Set 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. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby. 

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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

  3. Ingresa una consulta de SQL válida.

  4. Haz clic en Más y, luego, selecciona Opciones de consulta.

    Configuración de consulta

  5. Selecciona la opción Set a destination table for query results (Establecer una tabla de destino para los resultados de la consulta).

    Establecer destino

  6. En la sección Destino, selecciona el Conjunto de datos en el que deseas crear la tabla y, luego, elige un ID de la tabla.

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

  8. Opcional: En Ubicación de los datos, elige tu ubicación.

  9. Para actualizar la configuración de la consulta, haz clic en Guardar.

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

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

Por ejemplo, con la siguiente sentencia, se crea una tabla nueva llamada trips a partir de los datos de la tabla bikeshare_trips pública:

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

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

bq

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

Opcional: Proporciona la marca --location y establece 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 SQL estándar.

Si no se especifica una marca de disposición de escritura, el comportamiento predeterminado es escribir los resultados en la tabla solo si está vacía. Si la tabla existe y no está vacía, se muestra el error siguiente: Error de BigQuery en la operación de consulta: error durante el procesamiento del trabajo project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

Ejemplos:

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

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

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

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

Ingresa el comando siguiente para agregar los resultados de las consultas a una tabla de destino llamada mytable en mydataset. El conjunto de datos está en my-other-project, no en tu proyecto predeterminado. En el comando, se usa la marca --append_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, realiza una llamada al método jobs.insert, configura un trabajo query y, por último, incluye un valor para la propiedad destinationTable. Para controlar la disposición de escritura de una tabla de destino existente, configura la propiedad writeDisposition.

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

Go

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

bigquery/snippets/querying/bigquery_query_destination_table.go
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

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

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

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

async function 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

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

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.

BigQuery admite las siguientes fuentes de datos externas:

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

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:

  • Usar Cloud Console
  • Usa el comando bq de la herramienta de línea de comandos bq show.
  • Mediante una llamada al método de la API tables.get
  • Usa las bibliotecas cliente.
  • Consulta las vistas INFORMATION_SCHEMA (beta).

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

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

  2. Haz clic en el nombre de la tabla.

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

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

bq

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

En el ejemplo anterior, se ilustra lo siguiente:

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

Ejemplos:

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

bq show --format=prettyjson mydataset.mytable

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

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

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

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

API

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

Go

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

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

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

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

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

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

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


from google.cloud import bigquery

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

# TODO(developer): Set 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 y INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_* 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:
is_insertable_into STRING YES o NO, lo que depende de si la tabla admite declaraciones DML INSERT
is_typed STRING El valor es siempre NO
creation_time TIMESTAMP La fecha y hora de creación de la tabla
ddl STRING La declaración DDL que se puede usar para volver a crear la tabla, como CREATE TABLE o CREATE VIEW.
clone_time TIMESTAMP En el caso de las clonaciones de tabla (vista previa), el momento en que la tabla base se clonó 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 clone_time es igual al campo creation_time. Solo se aplica a las tablas que tienen table_type configurado como CLONE.
base_table_catalog STRING Para las clonaciones de tabla (vista previa), es el proyecto de la tabla base. Solo se aplica a las tablas que tienen table_type configurado como CLONE.
base_table_schema STRING Para las clonaciones de tabla (vista previa), es el conjunto de datos de la tabla base. Solo se aplica a las tablas que tienen table_type configurado como CLONE.
base_table_name STRING Para las clonaciones de tabla (vista previa), es el nombre de la tabla base. Solo se aplica a las tablas que tienen table_type configurado como CLONE.
default_collation_name STRING El nombre de la especificación de la intercalación predeterminada, si existe; en caso contrario, NULL.

Ejemplos

Ejemplo 1:

En el ejemplo siguiente, se recuperan los metadatos de todas las tablas en el conjunto de datos llamado mydataset. La consulta selecciona todas las columnas de la vista INFORMATION_SCHEMA.TABLES, excepto is_typed, que se reserva para uso futuro, y ddl, que se oculta en las consultas SELECT *. Los metadatos que se muestran corresponden a todas las tablas en 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).

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

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

Los resultados deberían verse de la siguiente manera. Para facilitar la lectura, algunas columnas se excluyen de los resultados.

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| 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 todas las tablas de tipo BASE TABLE de la vista INFORMATION_SCHEMA.TABLES. La columna is_typed queda excluida y la columna ddl está oculta. Los metadatos que se muestran corresponden a las tablas de mydataset en tu proyecto predeterminado.

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

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

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

Los resultados deberían verse de la siguiente manera. Para facilitar la lectura, algunas columnas se excluyen de los resultados.

  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-31 22:40:05 | CREATE TABLE myproject.mydataset.mytable1 |
  |                |               |                |            |                    |                     | (                                           |
  |                |               |                |            |                    |                     |   id INT64                                  |
  |                |               |                |            |                    |                     | );                                          |
  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+

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.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
'SELECT
   table_name, ddl
 FROM
   `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
 WHERE
   table_name="population_by_zip_2010"'

El resultado debería ser similar a lo 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
partition_expiration_days FLOAT64 El ciclo de vida predeterminado de todas las particiones de una tabla particionada, expresado en días
expiration_timestamp FLOAT64 La hora a la que vence esta tabla
kms_key_name STRING El nombre de la clave de Cloud KMS que se usa para encriptar la tabla
friendly_name STRING El nombre descriptivo de la tabla
description STRING Una descripción de la tabla
labels ARRAY<STRUCT<STRING, STRING>> Un arreglo de STRUCT que representa las etiquetas de la tabla
require_partition_filter BOOL Si las consultas sobre la tabla requieren un filtro de partición
enable_refresh BOOL Indica si la actualización automática está habilitada para una vista materializada
refresh_interval_minutes FLOAT64 Frecuencia con la que se actualiza una vista materializada

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

STRING

Una descripción de esta tabla.
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.
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 son los siguientes: AVRO, CSV, DATASTORE_BACKUP, GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (o JSON), ORC y PARQUET.

El valor JSON es equivalente a NEWLINE_DELIMITED_JSON.
decimal_target_types

ARRAY<STRING>

Determina cómo convertir un tipo Decimal. Equivale a ExternalDataConfiguration.decimal_target_types

Ejemplo: ["NUMERIC", "BIGNUMERIC"].
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.

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

STRING

La string que representa los valores NULL en un archivo CSV.

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.
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 desde el que se realiza la búsqueda.

Se aplica a los datos de Hojas de cálculo.

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 Hojas de cálculo.
uris

ARRAY<STRING>

Un arreglo de URI completamente calificados para las ubicaciones de datos externas.

Ejemplo: ["gs://bucket/path/*"].

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.

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

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

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

El resultado debería ser similar a lo 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.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

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

El resultado debería ser similar a lo 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 SQL estándar de la columna
IS_GENERATED STRING El valor es siempre NEVER
GENERATION_EXPRESSION STRING El valor es siempre NULL
IS_STORED STRING El valor es siempre NULL
IS_HIDDEN STRING YES o NO, lo cual depende de si 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

Ejemplos

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

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

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

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

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

Los resultados deberían verse de la siguiente manera. Para facilitar la lectura, algunas columnas se excluyen de los resultados.

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

Vista COLUMN_FIELD_PATHS

Cuando consultas la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, los resultados 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 SQL estándar 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.

Ejemplos

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

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

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

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

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

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

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

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

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

Los resultados deberían verse de la siguiente manera. Para facilitar la lectura, algunas columnas se excluyen de los resultados.

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

Vista TABLE_STORAGE

En la vista INFORMATION_SCHEMA.TABLE_STORAGE, se proporciona una instantánea actual del uso del almacenamiento para tablas y vistas materializadas. Cuando consultas la vista INFORMATION_SCHEMA.TABLE_STORAGE, los resultados contienen una fila por cada tabla o vista materializada. Los datos de esta tabla no se mantienen en tiempo real y pueden tardar unos segundos o unos minutos.

Los datos de la vista están regionalizados, por lo que debes usar un calificador de región en las consultas de la vista. Si no especificas un proyecto, se usa el proyecto predeterminado.

En los siguientes ejemplos, se ilustra cómo mostrar datos desde un proyecto o una región.

Muestra información de almacenamiento para las tablas en un proyecto específico:

SELECT * FROM myProject.`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

Muestra información de almacenamiento para las tablas en una región específica:

SELECT * FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

La vista INFORMATION_SCHEMA.TABLE_STORAGE tiene el siguiente esquema:

Nombre de la columna Tipo de datos Valor
PROJECT_ID STRING El ID del proyecto que contiene el conjunto de datos
PROJECT_NAME INT64 El número 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 fecha y 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 en la tabla o la vista materializada
ACTIVE_LOGICAL_BYTES INT64 Cantidad de bytes lógicos que tienen menos de 90 días
LONG_TERM_LOGICAL_BYTES INT64 Cantidad de bytes lógicos que tienen más de 90 días
TOTAL_PHYSICAL_BYTES INT64 Cantidad total de bytes físicos que se usan para el almacenamiento, incluidos los bytes activos, a largo plazo y de viaje en el tiempo (para las tablas borradas)
ACTIVE_PHYSICAL_BYTES INT64 Cantidad de bytes físicos con menos de 90 días de antigüedad
LONG_TERM_PHYSICAL_BYTES INT64 Cantidad de bytes físicos con más de 90 días de antigüedad
TIME_TRAVEL_PHYSICAL_BYTES INT64 Cantidad de bytes físicos que usa el almacenamiento de viaje en el tiempo (datos borrados o modificados)

Ejemplos

En el siguiente ejemplo, se muestran los proyectos de la organización que usan más almacenamiento.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

    SELECT
 project_id,
 SUM(total_logical_bytes) AS total_logical_bytes
FROM
 `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE
GROUP BY
 project_id
ORDER BY
 total_logical_bytes DESC;

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
   'SELECT
     project_id,
     SUM(total_logical_bytes) AS total_logical_bytes
   FROM
     `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE
   GROUP BY
     project_id
   ORDER BY
     total_logical_bytes DESC;'

Los resultados deberían ser similares a lo siguiente:

+---------------------+---------------------+
|     project_id      | total_logical_bytes |
+---------------------+---------------------+
| projecta            |     971329178274633 |
+---------------------+---------------------+
| projectb            |     834638211024843 |
+---------------------+---------------------+
| projectc            |     562910385625126 |
+---------------------+---------------------+

Vistas TABLE_STORAGE_TIMELINE_BY_*

Las vistas del cronograma de almacenamiento de la tabla muestran una fila por cada evento que activa un cambio de almacenamiento para la tabla, como escribir, actualizar o borrar una fila. Esto significa que puede haber varias filas para una tabla durante un solo día. Cuando consultes una vista para un intervalo de tiempo, usa la marca de tiempo más reciente el día de interés.

Las siguientes vistas del cronograma de almacenamiento de tablas están disponibles:

  • INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT muestra información de todas las tablas en el proyecto actual o especificado.
  • INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION muestra información de todas las tablas en la carpeta superior del proyecto actual o especificado, incluidos los proyectos en subcarpetas que contiene.

Los datos de la vista están regionalizados, por lo que debes usar un calificador de región en las consultas de la vista.

Las vistas del cronograma de almacenamiento de tablas tienen el siguiente esquema:

Nombre de la columna Tipo de datos Valor
TIMESTAMP TIMESTAMP Marca de tiempo del momento en que se volvió a calcular el almacenamiento. Los cambios en los datos de la tabla activan los cálculos nuevos.
DELETED BOOLEAN Indica si la tabla se borró o no
PROJECT_ID STRING El ID del proyecto que contiene el conjunto de datos
PROJECT_NAME INT64 El número 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 fecha y 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 para la tabla o la vista materializada. Las tablas no particionadas mostrarán 0.
TOTAL_LOGICAL_BYTES INT64 Cantidad total de bytes lógicos en la tabla o la vista materializada
ACTIVE_LOGICAL_BYTES INT64 Cantidad de bytes lógicos que tienen menos de 90 días
LONG_TERM_LOGICAL_BYTES INT64 Cantidad de bytes lógicos que tienen más de 90 días
TOTAL_PHYSICAL_BYTES INT64 Cantidad total de bytes físicos que se usan para el almacenamiento, incluidos los bytes activos, a largo plazo y de viaje en el tiempo (para las tablas borradas)
ACTIVE_PHYSICAL_BYTES INT64 Cantidad de bytes físicos con menos de 90 días de antigüedad
LONG_TERM_PHYSICAL_BYTES INT64 Cantidad de bytes físicos con más de 90 días de antigüedad
TIME_TRAVEL_PHYSICAL_BYTES INT64 Cantidad de bytes físicos que usa el almacenamiento de viaje en el tiempo (datos borrados o modificados)

Ejemplos

Ejemplo 1:

En el siguiente ejemplo, se muestra qué tablas usan más almacenamiento en un conjunto de datos específico.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

    SELECT
 timestamp AS start_time,
 table_name,
 total_logical_bytes
FROM
 `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT
WHERE
 table_schema = "TABLE_SCHEMA"
AND
 table_name = "TABLE_NAME"
ORDER BY
 start_time DESC;

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
   'SELECT
     timestamp AS start_time,
     table_name,
     total_logical_bytes
   FROM
     `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT
   WHERE
     table_schema = "TABLE_SCHEMA"
   AND
     table_name = "TABLE_NAME"
   ORDER BY
     start_time DESC;'

El resultado debería ser similar a lo siguiente:

------------------------+---------------------+----------------------+
|         start_time    |      table_name     | total_logical_bytes  |
+-----------------------+---------------------+----------------------+
| 2022-03-30 17:39:54   | table1              |              322     |
| 2022-03-30 17:39:54   | table2              |              1657    |
| 2022-03-30 17:39:53   | table1              |              320     |
| 2022-03-30 17:39:53   | table2              |              1655    |
+-----------------------+---------------------+----------------------+
Ejemplo 2:

En el siguiente ejemplo, se muestra la suma del almacenamiento físico que usa cada proyecto de la organización para un momento determinado.

Para ejecutar la consulta, haz lo siguiente:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página de BigQuery

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

    WITH most_recent_records as (
 SELECT
   project_id,
   table_schema,
   table_name,
   MAX(timestamp) as max_timestamp
 FROM
   `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
 WHERE
   timestamp <= "TIMESTAMP"
 GROUP BY
   project_id, table_schema, table_name
)
SELECT
 i_s.project_id,
 SUM(i_s.total_physical_bytes) AS TotalPhysicalBytes
FROM
 `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION as i_s
JOIN
 most_recent_records
ON
 i_s.project_id=most_recent_records.project_id AND
 i_s.table_schema=most_recent_records.table_schema AND
 i_s.table_name=most_recent_records.table_name AND
 i_s.timestamp = most_recent_records.max_timestamp
GROUP BY
 project_id;

  3. Haz clic en Ejecutar.

bq

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

Para ejecutar la consulta, ingresa lo siguiente:

bq query --nouse_legacy_sql \
  'WITH most_recent_records as (
     SELECT
       project_id,
       table_schema,
       table_name,
       MAX(timestamp) as max_timestamp
     FROM
       `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
     WHERE
       timestamp <= "TIMESTAMP"
     GROUP BY
       project_id, table_schema, table_name
   )
   SELECT
     i_s.project_id,
     SUM(i_s.total_physical_bytes) AS TotalPhysicalBytes
   FROM
     `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION as i_s
   JOIN
     most_recent_records
   ON
     i_s.project_id=most_recent_records.project_id AND
     i_s.table_schema=most_recent_records.table_schema AND
     i_s.table_name=most_recent_records.table_name AND
     i_s.timestamp = most_recent_records.max_timestamp
   GROUP BY
     project_id;'

Los resultados deberían ser similares a lo siguiente:

-----------------+------------------------+
|  project_id    |  TotalPhysicalBytes    |
+----------------+------------------------+
| projecta       | 3844                   |
| projectb       | 16022778               |
| projectc       | 8934009                |
+----------------+------------------------+

Enumera tablas en un conjunto de datos

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

  • Usa Cloud Console.
  • Usa el comando bq de la herramienta de línea de comandos bq ls.
  • 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.

Enumerar tablas

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

Console

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

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

bq

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

En el ejemplo anterior, se ilustra lo siguiente:

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

Ejemplos:

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#

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. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de BigQuery. 


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

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

Go

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

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"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

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

import com.google.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

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

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

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

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

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

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

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

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


from google.cloud import bigquery

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

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

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

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

Ruby

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

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.

Próximos pasos

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