Crear y usar 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 lo siguiente:

Después de crear una tabla, puedes hacer lo siguiente:

  • Controla el acceso a los datos de tu tabla.
  • Obtener información sobre tus tablas.
  • Muestra las tablas de un conjunto de datos.
  • Obtiene los metadatos de la tabla.

Para obtener más información sobre cómo gestionar tablas, como actualizar sus propiedades, copiarlas y eliminarlas, consulta el artículo Gestionar tablas.

Antes de empezar

Concede roles de gestión de identidades y accesos (IAM) que proporcionen a los usuarios los permisos necesarios para llevar a cabo cada tarea de este documento.

Roles obligatorios

Para obtener los permisos que necesitas para crear una tabla, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos:

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para crear una tabla. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para crear una tabla, se necesitan los siguientes permisos:

  • bigquery.tables.create en el conjunto de datos en el que vas a crear la tabla.
  • bigquery.tables.getData en todas las tablas y vistas a las que hace referencia tu consulta si guardas los resultados de la consulta en una tabla.
  • bigquery.jobs.create en el proyecto si creas la tabla cargando datos o guardando los resultados de una consulta en una tabla.
  • bigquery.tables.updateData en la tabla si vas a añadir o sobrescribir una tabla con los resultados de la consulta.

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Nombres de tablas

Cuando creas una tabla en BigQuery, el nombre de la tabla debe ser único por conjunto de datos. El nombre de la tabla puede:

  • Contener caracteres con un total de hasta 1024 bytes UTF-8.
  • Contener caracteres Unicode de las categorías L (letra), M (marca), N (número), Pc (conector, incluido el guion bajo), Pd (guion) y Zs (espacio). Para obtener más información, consulta la sección Categoría general.

Estos son ejemplos de nombres de tabla válidos: table 01, ग्राहक, 00_お客様 y étudiant-01.

Desventajas:

  • Los nombres de tabla distinguen entre mayúsculas y minúsculas de forma predeterminada. mytable y MyTable pueden coexistir en el mismo conjunto de datos, a menos que formen parte de un conjunto de datos con la opción de distinción entre mayúsculas y minúsculas desactivada.
  • Algunos nombres de tabla y prefijos de nombres de tabla están reservados. Si recibes un error que indica que el nombre o el prefijo de la tabla está reservado, selecciona otro nombre e inténtalo de nuevo.
  • Si incluyes varios operadores de punto (.) en una secuencia, los operadores duplicados se eliminan implícitamente.

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

    Se convierte en lo siguiente: project_name.dataset_name.table_name

Creación de tablas

Puedes crear una tabla en BigQuery de las siguientes formas:

  • Manualmente mediante la Google Cloud consola o la herramienta de línea de comandos bq bq mk.
  • De forma automatizada llamando al método de API tables.insert.
  • Usando las bibliotecas de cliente.
  • Desde los resultados de la consulta.
  • Definiendo una tabla que haga referencia a una fuente de datos externa.
  • Cuando cargas datos.
  • Mediante una CREATE TABLE declaración del lenguaje de definición de datos (DDL).

Crear 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 formas:

  • Introduce el esquema con la Google Cloud consola.
  • Proporciona el esquema de forma insertada con la herramienta de línea de comandos bq.
  • Envía un archivo de esquema JSON con la herramienta de línea de comandos bq.
  • Proporciona el esquema en un recurso de tabla al llamar al método tables.insert de las APIs.

Para obtener más información sobre cómo especificar un esquema de tabla, consulta Especificar un esquema.

Una vez creada la tabla, puede cargar datos en ella o rellenarla escribiendo resultados de consultas.

Para crear una tabla vacía con una definición de esquema, sigue estos pasos:

Consola

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

    Ir a BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.
  3. En la sección Información del conjunto de datos, haz clic en Crear tabla.
  4. En el panel Crear tabla, especifica los siguientes detalles:
    1. En la sección Fuente, selecciona Tabla vacía en la lista Crear tabla a partir de.
    2. En la sección Destino, especifica los siguientes detalles:
      1. En Conjunto de datos, selecciona el conjunto de datos en el que quieras crear la tabla.
      2. En el campo Tabla, introduce el nombre de la tabla que quieras crear.
      3. Verifica que el campo Tipo de tabla sea Tabla nativa.
    3. En la sección Schema (Esquema), introduce la definición de schema. Puede introducir la información del esquema manualmente mediante uno de los siguientes métodos:
      • Opción 1: Haz clic en Editar como texto y pega el esquema en forma de matriz JSON. Cuando usas una matriz JSON, generas el esquema siguiendo el mismo proceso que para crear un archivo de esquema JSON. Para ver el esquema de una tabla en formato JSON, introduce el siguiente comando:
            bq show --format=prettyjson dataset.table
            
      • Opción 2: Haz clic en Añadir campo e introduce el esquema de la tabla. Especifica el Nombre, Tipo y Modo de cada campo.
    4. Opcional: Especifica la configuración de partición y clúster. Para obtener más información, consulta los artículos sobre cómo crear tablas con particiones y cómo crear y usar tablas agrupadas en clústeres.
    5. Opcional: En la sección Opciones avanzadas, si quieres usar una clave de cifrado gestionada por el cliente, selecciona la opción Usar una clave de cifrado gestionada por el cliente (CMEK). De forma predeterminada, BigQuery encripta el contenido de los clientes almacenado en reposo mediante una Google-owned and Google-managed encryption key.
    6. Haz clic en Crear tabla.

SQL

En el siguiente ejemplo se crea una tabla llamada newtable que caduca el 1 de enero del 2023:

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

    Ir a BigQuery

  2. En el editor de consultas, introduce la siguiente instrucción:

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

  3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Usa el comando bq mk con la marca --table o -t. Puedes proporcionar información sobre el esquema de la tabla de forma directa o con un archivo de esquema JSON. Para ver una lista completa de parámetros, consulta la referencia de bq mk --table. Algunos parámetros opcionales son:

    • --expiration
    • --description
    • --time_partitioning_field
    • --time_partitioning_type
    • --range_partitioning
    • --clustering_fields
    • --destination_kms_key
    • --label

    --time_partitioning_field, --time_partitioning_type, --range_partitioning, --clustering_fields y --destination_kms_key no se muestran aquí. Consulta los siguientes enlaces para obtener más información sobre estos parámetros opcionales:

    Si vas a crear una tabla en un proyecto que no sea el predeterminado, añade el ID del proyecto al conjunto de datos con el siguiente formato: project_id:dataset.

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

    bq mk \
    --table \
    --expiration=integer \
    --description=description \
    --label=key_1:value_1 \
    --label=key_2:value_2 \
    --add_tags=key_3:value_3[,...] \
    project_id:dataset.table \
    schema

    Haz los cambios siguientes:

    • integer es el tiempo de vida predeterminado (en segundos) de la tabla. El valor mínimo es de 3600 segundos (una hora). La hora de vencimiento se calcula como la hora UTC actual más el valor entero. Si define la fecha de vencimiento al crear una tabla, se ignorará el ajuste de vencimiento de tabla predeterminado del conjunto de datos.
    • description es una descripción de la tabla entre comillas.
    • key_1:value_1 y key_2:value_2 son pares clave-valor que especifican etiquetas.
    • key_3:value_3 son pares clave-valor que especifican etiquetas. Añade varias etiquetas con la misma marca separando los pares clave-valor con comas.
    • project_id es el ID del proyecto.
    • dataset es un conjunto de datos de tu proyecto.
    • table es el nombre de la tabla que vas a crear.
    • schema es una definición de esquema insertada en el formato field:data_type,field:data_type o la ruta al archivo de esquema JSON en tu máquina local.

    Cuando especifica el esquema en la línea de comandos, no puede incluir un tipo RECORD (STRUCT) , no puede incluir una descripción de la columna y no puede especificar el modo de la columna. Todos los modos tienen el valor predeterminado NULLABLE. Para incluir descripciones, modos y tipos de RECORD, proporcione un archivo de esquema JSON.

    Ejemplos:

    Introduce el siguiente comando para crear una tabla con una definición de esquema insertada. Este comando crea una tabla llamada mytable en mydataset en tu proyecto predeterminado. La caducidad de la tabla se ha definido en 3600 segundos (1 hora), la descripción se ha definido en This is my table y la etiqueta se ha definido en organization:development. El comando usa la combinación de teclas -t en lugar de --table. El esquema se especifica de forma insertada 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

    Introduce 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. La caducidad de la tabla se ha definido en 3600 segundos (1 hora), la descripción se ha definido en This is my table y la etiqueta se ha definido en organization:development. La ruta al archivo de esquema es /tmp/myschema.json.

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

    Introduce el siguiente comando para crear una tabla con un archivo de esquema JSON. Este comando crea una tabla llamada mytable en mydataset en myotherproject. La caducidad de la tabla se ha definido en 3600 segundos (1 hora), la descripción se ha definido en This is my table y la etiqueta se ha definido en organization:development. La ruta al archivo de esquema es /tmp/myschema.json.

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

    Una vez creada la tabla, puedes actualizar su fecha de vencimiento, descripción y etiquetas. También puedes modificar la definición del esquema.

  3. Terraform

    Usa el recurso google_bigquery_table.

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

    Crear una tabla

    En el siguiente ejemplo se crea una tabla llamada mytable:

    resource "google_bigquery_dataset" "default" {
      dataset_id                      = "mydataset"
      default_partition_expiration_ms = 2592000000  # 30 days
      default_table_expiration_ms     = 31536000000 # 365 days
      description                     = "dataset description"
      location                        = "US"
      max_time_travel_hours           = 96 # 4 days
    
      labels = {
        billing_group = "accounting",
        pii           = "sensitive"
      }
    }
    
    resource "google_bigquery_table" "default" {
      dataset_id          = google_bigquery_dataset.default.dataset_id
      table_id            = "mytable"
      deletion_protection = false # set to "true" in production
    
      schema = <<EOF
    [
      {
        "name": "ID",
        "type": "INT64",
        "mode": "NULLABLE",
        "description": "Item ID"
      },
      {
        "name": "Item",
        "type": "STRING",
        "mode": "NULLABLE"
      }
    ]
    EOF
    
    }

    Crear una tabla y conceder acceso a ella

    En el siguiente ejemplo se crea una tabla llamada mytable y, a continuación, se usa el recurso google_bigquery_table_iam_policy para conceder acceso a ella. Sigue este paso solo si quieres conceder acceso a la tabla a principales que no tengan acceso al conjunto de datos en el que se encuentra la tabla.

    resource "google_bigquery_dataset" "default" {
      dataset_id                      = "mydataset"
      default_partition_expiration_ms = 2592000000  # 30 days
      default_table_expiration_ms     = 31536000000 # 365 days
      description                     = "dataset description"
      location                        = "US"
      max_time_travel_hours           = 96 # 4 days
    
      labels = {
        billing_group = "accounting",
        pii           = "sensitive"
      }
    }
    
    resource "google_bigquery_table" "default" {
      dataset_id          = google_bigquery_dataset.default.dataset_id
      table_id            = "mytable"
      deletion_protection = false # set to "true" in production
    
      schema = <<EOF
    [
      {
        "name": "ID",
        "type": "INT64",
        "mode": "NULLABLE",
        "description": "Item ID"
      },
      {
        "name": "Item",
        "type": "STRING",
        "mode": "NULLABLE"
      }
    ]
    EOF
    
    }
    
    data "google_iam_policy" "default" {
      binding {
        role = "roles/bigquery.dataOwner"
        members = [
          "user:raha@altostrat.com",
        ]
      }
    }
    
    resource "google_bigquery_table_iam_policy" "policy" {
      dataset_id  = google_bigquery_table.default.dataset_id
      table_id    = google_bigquery_table.default.table_id
      policy_data = data.google_iam_policy.default.policy_data
    }

    Crear una tabla con una clave de cifrado gestionada por el cliente

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

    resource "google_bigquery_dataset" "default" {
      dataset_id                      = "mydataset"
      default_partition_expiration_ms = 2592000000  # 30 days
      default_table_expiration_ms     = 31536000000 # 365 days
      description                     = "dataset description"
      location                        = "US"
      max_time_travel_hours           = 96 # 4 days
    
      labels = {
        billing_group = "accounting",
        pii           = "sensitive"
      }
    }
    
    resource "google_bigquery_table" "default" {
      dataset_id          = google_bigquery_dataset.default.dataset_id
      table_id            = "mytable"
      deletion_protection = false # set to "true" in production
    
      schema = <<EOF
    [
      {
        "name": "ID",
        "type": "INT64",
        "mode": "NULLABLE",
        "description": "Item ID"
      },
      {
        "name": "Item",
        "type": "STRING",
        "mode": "NULLABLE"
      }
    ]
    EOF
    
      encryption_configuration {
        kms_key_name = google_kms_crypto_key.crypto_key.id
      }
    
      depends_on = [google_project_iam_member.service_account_access]
    }
    
    resource "google_kms_crypto_key" "crypto_key" {
      name     = "example-key"
      key_ring = google_kms_key_ring.key_ring.id
    }
    
    resource "random_id" "default" {
      byte_length = 8
    }
    
    resource "google_kms_key_ring" "key_ring" {
      name     = "${random_id.default.hex}-example-keyring"
      location = "us"
    }
    
    # Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
    data "google_project" "project" {
    }
    
    resource "google_project_iam_member" "service_account_access" {
      project = data.google_project.project.project_id
      role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
      member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
    }

    Para aplicar la configuración de Terraform en un proyecto, sigue los pasos que se indican en las siguientes secciones. Google Cloud

    Preparar Cloud Shell

    1. Abre Cloud Shell.
    2. Define el Google Cloud proyecto Google Cloud predeterminado en el que quieras aplicar tus configuraciones de Terraform.

      Solo tiene que ejecutar este comando una vez por proyecto y puede hacerlo en cualquier directorio.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Las variables de entorno se anulan si defines valores explícitos en el archivo de configuración de Terraform.

    Preparar el directorio

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

    1. En Cloud Shell, crea un directorio y un archivo nuevo en ese directorio. El nombre del archivo debe tener la extensión .tf. Por ejemplo, main.tf. En este tutorial, nos referiremos al archivo como main.tf.
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf
    2. Si estás siguiendo un tutorial, puedes copiar el código de ejemplo de cada sección o paso.

      Copia el código de ejemplo en el archivo main.tf que acabas de crear.

      También puedes copiar el código de GitHub. Se recomienda cuando el fragmento de Terraform forma parte de una solución integral.

    3. Revisa y modifica los parámetros de ejemplo para aplicarlos a tu entorno.
    4. Guarda los cambios.
    5. Inicializa Terraform. Solo tienes que hacerlo una vez por directorio.
      terraform init

      Si quieres usar la versión más reciente del proveedor de Google, incluye la opción -upgrade:

      terraform init -upgrade

    Aplica los cambios

    1. Revisa la configuración y comprueba que los recursos que va a crear o actualizar Terraform se ajustan a tus expectativas:
      terraform plan

      Haga las correcciones necesarias en la configuración.

    2. Aplica la configuración de Terraform ejecutando el siguiente comando e introduciendo yes en la petición:
      terraform apply

      Espera hasta que Terraform muestre el mensaje "Apply complete!".

    3. Abre tu Google Cloud proyecto para ver los resultados. En la Google Cloud consola, ve a tus recursos en la interfaz de usuario para asegurarte de que Terraform los ha creado o actualizado.

    API

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

    C#

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

    Go

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    import (
    	"context"
    	"fmt"
    	"time"
    
    	"cloud.google.com/go/bigquery"
    )
    
    // createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
    func createTableExplicitSchema(projectID, datasetID, tableID string) error {
    	// projectID := "my-project-id"
    	// datasetID := "mydatasetid"
    	// tableID := "mytableid"
    	ctx := context.Background()
    
    	client, err := bigquery.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("bigquery.NewClient: %v", err)
    	}
    	defer client.Close()
    
    	sampleSchema := bigquery.Schema{
    		{Name: "full_name", Type: bigquery.StringFieldType},
    		{Name: "age", Type: bigquery.IntegerFieldType},
    	}
    
    	metaData := &bigquery.TableMetadata{
    		Schema:         sampleSchema,
    		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
    	}
    	tableRef := client.Dataset(datasetID).Table(tableID)
    	if err := tableRef.Create(ctx, metaData); err != nil {
    		return err
    	}
    	return nil
    }
    

    Java

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    import com.google.cloud.bigquery.BigQuery;
    import com.google.cloud.bigquery.BigQueryException;
    import com.google.cloud.bigquery.BigQueryOptions;
    import com.google.cloud.bigquery.Field;
    import com.google.cloud.bigquery.Schema;
    import com.google.cloud.bigquery.StandardSQLTypeName;
    import com.google.cloud.bigquery.StandardTableDefinition;
    import com.google.cloud.bigquery.TableDefinition;
    import com.google.cloud.bigquery.TableId;
    import com.google.cloud.bigquery.TableInfo;
    
    public class CreateTable {
    
      public static void runCreateTable() {
        // TODO(developer): Replace these variables before running the sample.
        String datasetName = "MY_DATASET_NAME";
        String tableName = "MY_TABLE_NAME";
        Schema schema =
            Schema.of(
                Field.of("stringField", StandardSQLTypeName.STRING),
                Field.of("booleanField", StandardSQLTypeName.BOOL));
        createTable(datasetName, tableName, schema);
      }
    
      public static void createTable(String datasetName, String tableName, Schema schema) {
        try {
          // Initialize client that will be used to send requests. This client only needs to be created
          // once, and can be reused for multiple requests.
          BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
    
          TableId tableId = TableId.of(datasetName, tableName);
          TableDefinition tableDefinition = StandardTableDefinition.of(schema);
          TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();
    
          bigquery.create(tableInfo);
          System.out.println("Table created successfully");
        } catch (BigQueryException e) {
          System.out.println("Table was not created. \n" + e.toString());
        }
      }
    }

    Node.js

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    // Import the Google Cloud client library and create a client
    const {BigQuery} = require('@google-cloud/bigquery');
    const bigquery = new BigQuery();
    
    async function createTable() {
      // Creates a new table named "my_table" in "my_dataset".
    
      /**
       * TODO(developer): Uncomment the following lines before running the sample.
       */
      // const datasetId = "my_dataset";
      // const tableId = "my_table";
      // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';
    
      // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
      const options = {
        schema: schema,
        location: 'US',
      };
    
      // Create a new table in the dataset
      const [table] = await bigquery
        .dataset(datasetId)
        .createTable(tableId, options);
    
      console.log(`Table ${table.id} created.`);
    }

    PHP

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    use Google\Cloud\BigQuery\BigQueryClient;
    
    /** Uncomment and populate these variables in your code */
    // $projectId = 'The Google project ID';
    // $datasetId = 'The BigQuery dataset ID';
    // $tableId = 'The BigQuery table ID';
    // $fields = [
    //    [
    //        'name' => 'field1',
    //        'type' => 'string',
    //        'mode' => 'required'
    //    ],
    //    [
    //        'name' => 'field2',
    //        'type' => 'integer'
    //    ],
    //];
    
    $bigQuery = new BigQueryClient([
        'projectId' => $projectId,
    ]);
    $dataset = $bigQuery->dataset($datasetId);
    $schema = ['fields' => $fields];
    $table = $dataset->createTable($tableId, ['schema' => $schema]);
    printf('Created table %s' . PHP_EOL, $tableId);

    Python

    Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    from google.cloud import bigquery
    
    # Construct a BigQuery client object.
    client = bigquery.Client()
    
    # TODO(developer): Set table_id to the ID of the table to create.
    # table_id = "your-project.your_dataset.your_table_name"
    
    schema = [
        bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
        bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
    ]
    
    table = bigquery.Table(table_id, schema=schema)
    table = client.create_table(table)  # Make an API request.
    print(
        "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
    )

    Ruby

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    require "google/cloud/bigquery"
    
    def create_table dataset_id = "my_dataset"
      bigquery = Google::Cloud::Bigquery.new
      dataset  = bigquery.dataset dataset_id
      table_id = "my_table"
    
      table = dataset.create_table table_id do |updater|
        updater.string  "full_name", mode: :required
        updater.integer "age",       mode: :required
      end
    
      puts "Created table: #{table_id}"
    end

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

Java

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

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

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

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

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

Crear una tabla a partir del resultado de una consulta

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

Consola

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

    Ir a la página de BigQuery

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

  3. Introduce una consulta de SQL válida.

  4. Haz clic en Más y, a continuación, selecciona Configuración de la consulta.

    Configuración de consultas

  5. Selecciona la opción Definir una tabla de destino para los resultados de las consultas.

    Definir destino

  6. En la sección Destino, seleccione el Conjunto de datos en el que quiera crear la tabla y, a continuación, elija un ID de tabla.

  7. En la sección Preferencia de escritura de la tabla de destino, elija una de las siguientes opciones:

    • Escribir si está vacía: escribe los resultados de la consulta en la tabla solo si está vacía.
    • Añadir a tabla: añade los resultados de la consulta a una tabla.
    • Sobrescribir tabla: sobrescribe una tabla con el mismo nombre con los resultados de la consulta.
  8. Opcional: En Ubicación de los datos, elija su ubicación.

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

  10. Haz clic en Ejecutar. De esta forma, se crea una tarea de consulta que escribe los resultados de la consulta en la tabla que ha especificado.

Si olvidas especificar una tabla de destino antes de ejecutar la consulta, puedes copiar la tabla de resultados almacenada en caché en una tabla permanente haciendo clic en el botón Guardar resultados situado encima del editor.

SQL

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

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

    Ir a BigQuery

  2. En el editor de consultas, introduce la siguiente instrucción:

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

  3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

Para obtener más información, consulta el artículo Crear una tabla a partir de otra tabla.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Introduce el comando bq query y especifica la marca --destination_table para crear una tabla permanente basada en los resultados de la consulta. Especifica la marca use_legacy_sql=false para usar la sintaxis de GoogleSQL. Para escribir los resultados de la consulta en una tabla que no esté en tu proyecto predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: project_id:dataset.

    Opcional: Proporciona la marca --location y asigna el valor a tu ubicación.

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

    • --append_table: si la tabla de destino existe, los resultados de la consulta se añaden a ella.
    • --replace: Si la tabla de destino ya existe, se sobrescribe con los resultados de la consulta.

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

      Haz los cambios siguientes:

    • 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 asignar el valor asia-northeast1 a la marca. Puedes definir 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 se escriben los resultados de la consulta.

    • table es el nombre de la tabla en la que se escriben los resultados de la consulta.

    • query es una consulta con sintaxis de GoogleSQL.

      Si no se especifica ninguna 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 devuelve el siguiente error: BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1: Already Exists: Table project_id:dataset.table.

      Ejemplos:

      Introduce el siguiente comando para escribir los resultados de la consulta en una tabla de destino llamada mytable en mydataset. El conjunto de datos está en tu proyecto predeterminado. Como no se ha especificado ninguna marca de disposición de escritura en el comando, la tabla debe ser nueva o estar vacía. De lo contrario, se devuelve un error Already exists. La consulta obtiene datos del conjunto de datos público USA Name Data.

      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'

      Introduce el siguiente comando para usar los resultados de la consulta y sobrescribir una tabla de destino llamada mytable en mydataset. El conjunto de datos está en tu proyecto predeterminado. El comando usa la marca --replace para sobrescribir 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'

      Introduce el siguiente comando para añadir los resultados de la consulta a una tabla de destino llamada mytable en mydataset. El conjunto de datos está en my-other-project, no en tu proyecto predeterminado. El comando usa la marca --append_table para añadir los resultados de la consulta 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 es el siguiente. Para mejorar la legibilidad, se ha truncado parte del resultado.

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

API

Para guardar los resultados de una consulta en una tabla permanente, llama al método jobs.insert, configura una tarea query e incluye un valor para la propiedad destinationTable. Para controlar la disposición de escritura de una tabla de destino, configura la propiedad writeDisposition.

Para controlar la ubicación de procesamiento de la tarea de consulta, especifica la propiedad location en la sección jobReference del recurso Job.

Go

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

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

Java

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

TableId que quieras a la tabla de destino 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 Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

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

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

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

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

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

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

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Para guardar los resultados de una consulta en una tabla permanente, crea un objeto QueryJobConfig y asigna el objeto destination al objeto TableReference que quieras. Transfiere la configuración de la tarea al método query.
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))

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

Las fuentes de datos externas se pueden consultar directamente desde BigQuery, aunque los datos no estén almacenados ahí. Por ejemplo, puedes tener datos en una base de datos Google Cloud diferente, en archivos de Cloud Storage o en cualquier otro producto de la nube que quieras analizar en BigQuery, pero que no vayas a migrar.

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

Crear una tabla al cargar datos

Cuando cargas datos en BigQuery, puedes hacerlo en una tabla o partición nuevas, añadir datos a una tabla o partición ya creada, o sobrescribir una tabla o partición. No es necesario crear una tabla vacía antes de cargar datos en ella. Puedes crear la tabla y cargar los datos al mismo tiempo.

Cuando cargas datos en BigQuery, puedes proporcionar el esquema de la tabla o de la partición. En el caso de los formatos de datos admitidos, puedes usar la detección automática del esquema.

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

Controlar el acceso a las tablas

Para configurar el acceso a tablas y vistas, puede asignar un rol de gestión de identidades y accesos a una entidad en los siguientes niveles, que se indican en orden de rango de recursos permitidos (del mayor al menor):

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

El acceso a cualquier recurso protegido por IAM es aditivo. Por ejemplo, si una entidad no tiene acceso a un nivel alto, como un proyecto, puedes concederle acceso a nivel de conjunto de datos. De esta forma, la entidad tendrá acceso a las tablas y vistas del conjunto de datos. Del mismo modo, si la entidad no tiene acceso a nivel superior o de conjunto de datos, puedes concederle acceso a nivel de tabla o de vista.

Si asignas roles de IAM a un nivel superior de la Google Cloudjerarquía de recursos , como el nivel de proyecto, carpeta u organización, la entidad tendrá acceso a un amplio conjunto de recursos. Por ejemplo, si asignas un rol a una entidad a nivel de proyecto, esa entidad tendrá permisos que se aplican a todos los conjuntos de datos del proyecto.

Si se concede un rol 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 concreto, aunque la entidad no tenga acceso a un nivel superior. Para obtener información sobre cómo configurar controles de acceso a nivel de conjunto de datos, consulta el artículo Controlar el acceso a los conjuntos de datos.

Si se asigna un rol a nivel de tabla o de vista, se especifican las operaciones que puede realizar una entidad en tablas y vistas concretas, aunque no tenga acceso a un nivel superior. Para obtener información sobre cómo configurar controles de acceso a nivel de tabla, consulta el artículo Controlar el acceso a tablas y vistas.

También puedes crear roles personalizados de gestión de identidades y accesos. Si creas un rol personalizado, los permisos que concedas dependerán de las operaciones específicas que quieras que pueda realizar la entidad.

No puedes definir 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 el artículo sobre descripción de roles de la documentación de gestión de identidades y accesos y los roles y permisos de gestión de identidades y accesos de BigQuery.

Obtener información sobre las tablas

Puede obtener información o metadatos sobre las tablas de las siguientes formas:

  • Con la Google Cloud consola.
  • Usa el comando bq show de la herramienta de línea de comandos bq.
  • Llamar al método de API tables.get.
  • Usar las bibliotecas de cliente.
  • Consultar la vista INFORMATION_SCHEMA.VIEWS.

Permisos obligatorios

Para obtener información sobre las tablas, como mínimo debes tener permisos de bigquery.tables.get. Los siguientes roles de gestión de identidades y accesos predefinidos incluyen los permisos de bigquery.tables.get:

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

Además, si un usuario tiene permisos de bigquery.datasets.create, cuando cree un conjunto de datos, se le concederá acceso de bigquery.dataOwner a él. bigquery.dataOwner permite al usuario recuperar metadatos de la tabla.

Para obtener más información sobre los roles y permisos de gestión de identidades y accesos en BigQuery, consulta el artículo sobre el control de acceso.

Obtener información de una tabla

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

Consola

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

  2. Haz clic en el nombre del conjunto de datos para desplegarlo. Se muestran las tablas y las vistas del conjunto de datos.

  3. Haz clic en el nombre de la tabla.

  4. En el panel Detalles, haz clic en Detalles para ver la descripción y la información de la tabla.

  5. También puede cambiar a la pestaña Esquema para ver la definición del esquema de la tabla.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

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

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

    Donde:

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

    Ejemplos:

    Introduce 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

    Introduce 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

    Introduce el siguiente comando 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
  3. API

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

    Go

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    import (
    	"context"
    	"fmt"
    	"io"
    
    	"cloud.google.com/go/bigquery"
    )
    
    // printTableInfo demonstrates fetching metadata from a table and printing some basic information
    // to an io.Writer.
    func printTableInfo(w io.Writer, projectID, datasetID, tableID string) error {
    	// projectID := "my-project-id"
    	// datasetID := "mydataset"
    	// tableID := "mytable"
    	ctx := context.Background()
    	client, err := bigquery.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("bigquery.NewClient: %v", err)
    	}
    	defer client.Close()
    
    	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
    	if err != nil {
    		return err
    	}
    	// Print basic information about the table.
    	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
    	fmt.Fprintf(w, "Description: %s\n", meta.Description)
    	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
    	return nil
    }
    

    Java

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    import com.google.cloud.bigquery.BigQuery;
    import com.google.cloud.bigquery.BigQueryException;
    import com.google.cloud.bigquery.BigQueryOptions;
    import com.google.cloud.bigquery.Table;
    import com.google.cloud.bigquery.TableId;
    
    public class GetTable {
    
      public static void runGetTable() {
        // TODO(developer): Replace these variables before running the sample.
        String projectId = "bigquery_public_data";
        String datasetName = "samples";
        String tableName = "shakespeare";
        getTable(projectId, datasetName, tableName);
      }
    
      public static void getTable(String projectId, String datasetName, String tableName) {
        try {
          // Initialize client that will be used to send requests. This client only needs to be created
          // once, and can be reused for multiple requests.
          BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
    
          TableId tableId = TableId.of(projectId, datasetName, tableName);
          Table table = bigquery.getTable(tableId);
          System.out.println("Table info: " + table.getDescription());
        } catch (BigQueryException e) {
          System.out.println("Table not retrieved. \n" + e.toString());
        }
      }
    }

    Node.js

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    // Import the Google Cloud client library
    const {BigQuery} = require('@google-cloud/bigquery');
    const bigquery = new BigQuery();
    
    async function getTable() {
      // Retrieves table named "my_table" in "my_dataset".
    
      /**
       * TODO(developer): Uncomment the following lines before running the sample
       */
      // const datasetId = "my_dataset";
      // const tableId = "my_table";
    
      // Retrieve table reference
      const dataset = bigquery.dataset(datasetId);
      const [table] = await dataset.table(tableId).get();
    
      console.log('Table:');
      console.log(table.metadata.tableReference);
    }
    getTable();

    PHP

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    use Google\Cloud\BigQuery\BigQueryClient;
    
    /** Uncomment and populate these variables in your code */
    //$projectId = 'The Google project ID';
    //$datasetId = 'The BigQuery dataset ID';
    //$tableId   = 'The BigQuery table ID';
    
    $bigQuery = new BigQueryClient([
        'projectId' => $projectId,
    ]);
    $dataset = $bigQuery->dataset($datasetId);
    $table = $dataset->table($tableId);

    Python

    Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    
    from google.cloud import bigquery
    
    # Construct a BigQuery client object.
    client = bigquery.Client()
    
    # TODO(developer): Set table_id to the ID of the model to fetch.
    # table_id = 'your-project.your_dataset.your_table'
    
    table = client.get_table(table_id)  # Make an API request.
    
    # View table properties
    print(
        "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
    )
    print("Table schema: {}".format(table.schema))
    print("Table description: {}".format(table.description))
    print("Table has {} rows".format(table.num_rows))

Obtener información de una tabla con INFORMATION_SCHEMA

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

Puedes consultar las siguientes vistas para obtener información sobre las tablas:

  • Usa las vistas INFORMATION_SCHEMA.TABLES y INFORMATION_SCHEMA.TABLE_OPTIONS para obtener metadatos sobre las tablas y las vistas de un proyecto.
  • Usa las vistas INFORMATION_SCHEMA.COLUMNS y INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para obtener metadatos sobre las columnas (campos) de una tabla.
  • Usa las vistas INFORMATION_SCHEMA.TABLE_STORAGE para obtener metadatos sobre el uso del almacenamiento actual e histórico de una tabla.

Las vistas TABLES y TABLE_OPTIONS también contienen información general sobre las vistas. Para obtener información detallada, consulta la vista INFORMATION_SCHEMA.VIEWS.

TABLES vista

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

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 Nombre del conjunto de datos que contiene la tabla o la vista. También se denomina datasetId.
table_name STRING Nombre de la tabla o de la vista. También se denomina tableId.
table_type STRING El tipo de tabla, que puede ser uno de los siguientes:
managed_table_type STRING Esta columna está en versión preliminar. El tipo de tabla gestionada, que puede ser uno de los siguientes:
is_insertable_into STRING YES o NO, en función de si la tabla admite instrucciones INSERT de DML
is_fine_grained_mutations_enabled STRING YES o NO en función de si las mutaciones de DML detalladas están habilitadas en la tabla
is_typed STRING El valor es siempre NO.
is_change_history_enabled STRING YES o NO, según si el historial de cambios está habilitado.
creation_time TIMESTAMP Hora de creación de la tabla
base_table_catalog STRING En el caso de las clones de tabla y las instantáneas de tabla, el proyecto de la tabla base. Solo se aplica a las tablas en las que table_type tiene el valor CLONE o SNAPSHOT.
base_table_schema STRING En el caso de los clones de tabla y las instantáneas de tabla, el conjunto de datos de la tabla base. Solo se aplica a las tablas con el valor CLONE o SNAPSHOT en table_type.
base_table_name STRING En el caso de los clones de tabla y las instantáneas de tabla, el nombre de la tabla base. Solo se aplica a las tablas con el valor CLONE o SNAPSHOT en table_type.
snapshot_time_ms TIMESTAMP En el caso de los clones de tabla y las instantáneas de tabla, se indica la hora en la que se ejecutó la operación de clonación o de creación de instantánea en la tabla base para crear esta tabla. Si se ha usado la función de viaje en el tiempo, este campo contiene la marca de tiempo correspondiente. De lo contrario, el campo snapshot_time_ms es el mismo que el campo creation_time. Solo se aplica a las tablas en las que table_type tiene el valor CLONE o SNAPSHOT.
replica_source_catalog STRING En el caso de las réplicas de vistas materializadas, se trata del proyecto de la vista materializada base.
replica_source_schema STRING En el caso de las réplicas de vistas materializadas, se trata del conjunto de datos de la vista materializada base.
replica_source_name STRING En el caso de las réplicas de vistas materializadas, el nombre de la vista materializada base.
replication_status STRING En el caso de las réplicas de vistas materializadas, el estado de la replicación de la vista materializada base a la réplica de la vista materializada. Puede ser uno de los siguientes:
  • REPLICATION_STATUS_UNSPECIFIED
  • ACTIVE: la replicación está activa y no hay errores
  • SOURCE_DELETED: se ha eliminado la vista materializada de origen
  • PERMISSION_DENIED: La vista materializada de origen no se ha autorizado en el conjunto de datos que contiene las tablas de BigLake de Amazon S3 de origen que se han usado en la consulta que ha creado la vista materializada.
  • UNSUPPORTED_CONFIGURATION: Hay un problema con los requisitos de la réplica que no está relacionado con la autorización de la vista materializada de origen.
replication_error STRING Si replication_status indica un problema de replicación de una réplica de vista materializada, replication_error proporciona más detalles sobre el problema.
ddl STRING La declaración de DDL que se puede usar para volver a crear la tabla, como CREATE TABLE o CREATE VIEW
default_collation_name STRING El nombre de la especificación de ordenación predeterminada, si existe. De lo contrario, NULL.
upsert_stream_apply_watermark TIMESTAMP En las tablas que usan la captura de datos de cambios (CDC), se indica la hora en la que se aplicaron por última vez las modificaciones de las filas. Para obtener más información, consulta Monitor the progress of a table upsert operation (Monitorizar el progreso de una operación de upsert de tabla).

Ejemplos

Ejemplo 1:

En el siguiente ejemplo se obtienen los metadatos de todas las tablas del conjunto de datos llamado mydataset. Los metadatos que se devuelven son de todos los tipos de tablas de mydataset de tu proyecto predeterminado.

mydataset contiene las siguientes tablas:

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

Para ejecutar la consulta en un proyecto que no sea el predeterminado, añade el ID del proyecto al conjunto de datos con el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

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

El resultado es similar al siguiente. Para mejorar la legibilidad, algunas columnas se han excluido del resultado.

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

En el siguiente ejemplo se obtienen los metadatos de todas las tablas de tipo CLONE o SNAPSHOT de la vista INFORMATION_SCHEMA.TABLES. Los metadatos devueltos corresponden a las tablas de mydataset de su proyecto predeterminado.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, añade el ID del proyecto al conjunto de datos con el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

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

El resultado es similar al siguiente. Para mejorar la legibilidad, algunas columnas se han excluido del resultado.

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

Ejemplo 3:

En el siguiente ejemplo se obtienen las columnas table_name y ddl de la vista INFORMATION_SCHEMA.TABLES de la tabla population_by_zip_2010 del conjunto de datos census_bureau_usa. Este conjunto de datos forma parte del programa de conjuntos de datos públicos de BigQuery.

Como la tabla que estás consultando está en otro proyecto, debes añadir el ID del proyecto al conjunto de datos con el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view. En este ejemplo, el valor es `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

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

El resultado es similar al siguiente:

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

TABLE_OPTIONS vista

Cuando consultas la vista INFORMATION_SCHEMA.TABLE_OPTIONS, los resultados de la consulta 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.

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 Nombre del conjunto de datos que contiene la tabla o la vista, también denominado datasetId
TABLE_NAME STRING Nombre de la tabla o de la vista, también conocido como 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 de la tabla de opciones
OPTION_VALUE STRING Una de las opciones de valor de la tabla de opciones
Tabla de opciones

OPTION_NAME

OPTION_TYPE

OPTION_VALUE

description

STRING

Una descripción de la tabla

enable_refresh

BOOL

Si la actualización automática está habilitada en una vista materializada

expiration_timestamp

TIMESTAMP

La hora en la que caduca esta tabla

friendly_name

STRING

Nombre descriptivo de la tabla

kms_key_name

STRING

Nombre de la clave de Cloud KMS que se usa para cifrar la tabla.

labels

ARRAY<STRUCT<STRING, STRING>>

Es un array de STRUCT que representa las etiquetas de la tabla.

max_staleness

INTERVAL

La antigüedad máxima de la tabla configurada para las inserciones y actualizaciones de captura de datos de cambios (CDC) de BigQuery

partition_expiration_days

FLOAT64

Tiempo de vida predeterminado, en días, de todas las particiones de una tabla con particiones.

refresh_interval_minutes

FLOAT64

Con qué frecuencia se actualiza una vista materializada

require_partition_filter

BOOL

Indica si las consultas en la tabla requieren un filtro de partición.

tags

ARRAY<STRUCT<STRING, STRING>>

Etiquetas asociadas a una tabla con la sintaxis <clave, valor> de espacio de nombres. Para obtener más información, consulta el artículo sobre etiquetas y acceso condicional.

En el caso de las tablas externas, se pueden usar las siguientes opciones:

Opciones
allow_jagged_rows

BOOL

Si es true, permite las filas que no tengan columnas opcionales finales.

Se aplica a los datos CSV.

allow_quoted_newlines

BOOL

Si true, permite secciones de datos entre comillas que contengan caracteres de salto de línea en el archivo.

Se aplica a los datos CSV.

bigtable_options

STRING

Solo es obligatorio cuando se crea una tabla externa de Bigtable.

Especifica el esquema de la tabla externa de Bigtable en formato JSON.

Para ver una lista de las opciones de definición de tablas de Bigtable, consulta BigtableOptions en la referencia de la API REST.

column_name_character_map

STRING

Define el ámbito de los caracteres admitidos en los nombres de columna y el comportamiento de los caracteres no admitidos. El ajuste predeterminado es STRICT, lo que significa que los caracteres no admitidos provocan que BigQuery genere errores. V1 y V2 sustituyen los caracteres no admitidos por guiones bajos.

Entre los valores admitidos se incluyen los siguientes:

compression

STRING

El tipo de compresión de la fuente de datos. Los valores admitidos son: GZIP. Si no se especifica, la fuente de datos no se comprime.

Se aplica a los datos CSV y JSON.

decimal_target_types

ARRAY<STRING>

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

Ejemplo: ["NUMERIC", "BIGNUMERIC"]

description

STRING

Descripción de esta tabla.

enable_list_inference

BOOL

Si true, usa la inferencia de esquemas específicamente para el tipo lógico LIST de Parquet.

Se aplica a los datos de Parquet.

enable_logical_types

BOOL

Si 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. Entre los valores admitidos se incluyen los siguientes: UTF8 (o UTF-8), ISO_8859_1 (o ISO-8859-1), UTF-16BE, UTF-16LE, UTF-32BE o UTF-32LE. El valor predeterminado es UTF-8.

Se aplica a los datos CSV.

enum_as_string

BOOL

Si true, infiere el tipo lógico ENUM de Parquet como STRING en lugar de BYTES de forma predeterminada.

Se aplica a los datos de Parquet.

expiration_timestamp

TIMESTAMP

La hora en la que caduca esta tabla. Si no se especifica, la tabla no caduca.

Ejemplo: "2025-01-01 00:00:00 UTC"

field_delimiter

STRING

El separador de los campos de un archivo CSV.

Se aplica a los datos CSV.

format

STRING

El formato de los datos externos. Los valores admitidos para CREATE EXTERNAL TABLE son: AVRO, CLOUD_BIGTABLE, CSV, DATASTORE_BACKUP, DELTA_LAKE (vista previa), GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (o JSON), ORC y PARQUET.

Los valores admitidos para LOAD DATA son: AVRO, CSV, DELTA_LAKE (vista previa) NEWLINE_DELIMITED_JSON (o JSON), ORC y PARQUET.

El valor JSON equivale a NEWLINE_DELIMITED_JSON.

hive_partition_uri_prefix

STRING

Prefijo común de todos los URIs de origen antes de que empiece la codificación de la clave de partición. Solo se aplica a las tablas externas con particiones de Hive.

Se aplica a los datos de Avro, CSV, JSON, Parquet y ORC.

Ejemplo: "gs://bucket/path"

file_set_spec_type

STRING

Especifica cómo interpretar los URIs de origen de las tareas de carga y las tablas externas.

Entre los valores admitidos se incluyen los siguientes:

  • FILE_SYSTEM_MATCH. Amplía los URIs de origen mostrando los archivos del almacén de objetos. Este es el comportamiento predeterminado si no se define FileSetSpecType.
  • NEW_LINE_DELIMITED_MANIFEST. Indica que los URIs proporcionados son archivos de manifiesto delimitados por saltos de línea, con un URI por línea. Las URIs comodín no se admiten en los archivos de manifiesto y todos los archivos de datos a los que se haga referencia deben estar en el mismo segmento que el archivo de manifiesto.

Por ejemplo, si tiene un URI de origen "gs://bucket/path/file" y el file_set_spec_type es FILE_SYSTEM_MATCH, el archivo se usa directamente como archivo de datos. Si el file_set_spec_type es NEW_LINE_DELIMITED_MANIFEST, cada línea del archivo se interpreta como un URI que apunta a un archivo de datos.

ignore_unknown_values

BOOL

Si es true, ignora los valores adicionales que no estén representados en el esquema de la tabla sin devolver un error.

Se aplica a los datos CSV y JSON.

json_extension

STRING

En el caso de los datos JSON, indica un formato de intercambio JSON concreto. Si no se especifica, BigQuery lee los datos como registros JSON genéricos.

Los valores admitidos son los siguientes:
GEOJSON. Datos de GeoJSON delimitados por líneas nuevas. Para obtener más información, consulta el artículo Crear una tabla externa a partir de un archivo GeoJSON delimitado por líneas nuevas.

max_bad_records

INT64

Número máximo de registros incorrectos que se deben ignorar al leer los datos.

Se aplica a los datos CSV, JSON y de Hojas de cálculo de Google.

max_staleness

INTERVAL

Se aplica a las tablas de BigLake y a las tablas de objetos.

Especifica si las operaciones de la tabla usan metadatos almacenados en caché y cuánto tiempo deben haber pasado desde la última actualización de los metadatos almacenados en caché para que la operación los pueda usar.

Para inhabilitar el almacenamiento en caché de metadatos, especifica 0. Este es el valor predeterminado.

Para habilitar el almacenamiento en caché de metadatos, especifica un valor de literal de intervalo entre 30 minutos y 7 días. Por ejemplo, especifica INTERVAL 4 HOUR para un intervalo de obsolescencia de 4 horas. Con este valor, las operaciones en la tabla usan metadatos almacenados en caché si se han actualizado en las últimas 4 horas. Si los metadatos almacenados en caché son anteriores a esa fecha, la operación recurre a la recuperación de metadatos de Cloud Storage.

null_marker

STRING

Cadena que representa los valores de NULL en un archivo CSV.

Se aplica a los datos CSV.

null_markers

ARRAY<STRING>

Vista previa

Lista de cadenas que representan valores NULL en un archivo CSV.

Esta opción no se puede usar con la opción null_marker.

Se aplica a los datos CSV.

object_metadata

STRING

Solo es obligatorio cuando se crea una tabla de objetos.

Asigna el valor SIMPLE a esta opción cuando crees una tabla de objetos.

preserve_ascii_control_characters

BOOL

Si true, se conservan los caracteres de control ASCII insertados, que son los 32 primeros caracteres de la tabla ASCII, que van de "\x00" a "\x1F".

Se aplica a los datos CSV.

projection_fields

STRING

Lista de propiedades de la entidad que se van a cargar.

Se aplica a los datos de Datastore.

quote

STRING

Cadena que se usa para poner entre comillas las secciones de datos de un archivo CSV. Si sus datos contienen caracteres de salto de línea entre comillas, también debe asignar el valor true a la propiedad allow_quoted_newlines.

Se aplica a los datos CSV.

reference_file_schema_uri

STRING

Archivo de referencia proporcionado por el usuario con el esquema de la tabla.

Se aplica a los datos de Parquet, ORC y AVRO.

Ejemplo: "gs://bucket/path/reference_schema_file.parquet"

require_hive_partition_filter

BOOL

Si true, todas las consultas de esta tabla requieren un filtro de partición que se pueda usar para descartar particiones al leer datos. Solo se aplica a las tablas externas con particiones de Hive.

Se aplica a los datos de Avro, CSV, JSON, Parquet y ORC.

sheet_range

STRING

Intervalo de una hoja de cálculo de Google del que se va a obtener información.

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

Ejemplo: "sheet1!A1:B20",

skip_leading_rows

INT64

Número de filas de la parte superior de un archivo que se deben omitir al leer los datos.

Se aplica a los datos de archivos CSV y de Hojas de cálculo de Google.

source_column_match

STRING

Vista previa

Controla la estrategia utilizada para asociar las columnas cargadas al esquema.

Si no se especifica ningún valor, el valor predeterminado se basa en cómo se proporciona el esquema. Si la detección automática está habilitada, el comportamiento predeterminado es hacer coincidir las columnas por nombre. De lo contrario, las columnas se emparejan por posición de forma predeterminada. Esto se hace para mantener la retrocompatibilidad.

Entre los valores admitidos se incluyen los siguientes:

  • POSITION: coincidencias por posición. Esta opción da por supuesto que las columnas están ordenadas de la misma forma que el esquema.
  • NAME: coincide por nombre. Esta opción lee la fila de encabezado como nombres de columna y reordena las columnas para que coincidan con los nombres de los campos del esquema. Los nombres de las columnas se leen de la última fila omitida en función de la propiedad skip_leading_rows.
tags <ARRAY<STRUCT<STRING, STRING>>>

Es un array de etiquetas de gestión de identidades y accesos de la tabla, expresado como pares clave-valor. La clave debe ser el nombre de la clave con espacio de nombres y el valor debe ser el nombre abreviado.

time_zone

STRING

Vista previa

Zona horaria predeterminada que se aplicará al analizar valores de marca de tiempo que no tengan una zona horaria específica.

Consulta los nombres de zonas horarias válidos.

Si no se incluye este valor, las marcas de tiempo sin una zona horaria específica se analizan con la zona horaria predeterminada UTC.

Se aplica a los datos CSV y JSON.

date_format

STRING

Vista previa

Elementos de formato que definen cómo se les da formato a los valores DATE en los archivos de entrada (por ejemplo, MM/DD/YYYY).

Si este valor está presente, este formato es el único compatible con DATE. La detección automática de esquemas también determinará el tipo de columna DATE en función de este formato en lugar del formato actual.

Si no se incluye este valor, el campo DATE se analiza con los formatos predeterminados.

Se aplica a los datos CSV y JSON.

datetime_format

STRING

Vista previa

Elementos de formato que definen cómo se formatean los valores DATETIME en los archivos de entrada (por ejemplo, MM/DD/YYYY HH24:MI:SS.FF3).

Si este valor está presente, este formato es el único compatible con DATETIME. La detección automática de esquemas también determinará el tipo de columna DATETIME en función de este formato en lugar del formato actual.

Si no se incluye este valor, el campo DATETIME se analiza con los formatos predeterminados.

Se aplica a los datos CSV y JSON.

time_format

STRING

Vista previa

Elementos de formato que definen cómo se formatean los valores TIME en los archivos de entrada (por ejemplo, HH24:MI:SS.FF3).

Si este valor está presente, este formato es el único compatible con TIME. La detección automática de esquemas también decidirá el tipo de columna TIME en función de este formato en lugar del formato actual.

Si no se incluye este valor, el campo TIME se analiza con los formatos predeterminados.

Se aplica a los datos CSV y JSON.

timestamp_format

STRING

Vista previa

Elementos de formato que definen cómo se formatean los valores TIMESTAMP en los archivos de entrada (por ejemplo, MM/DD/YYYY HH24:MI:SS.FF3).

Si este valor está presente, este formato es el único compatible con TIMESTAMP. La detección automática de esquemas también determinará el tipo de columna TIMESTAMP en función de este formato en lugar del formato actual.

Si no se incluye este valor, el campo TIMESTAMP se analiza con los formatos predeterminados.

Se aplica a los datos CSV y JSON.

uris

En el caso de las tablas externas, incluidas las tablas de objetos, que no sean tablas de Bigtable:

ARRAY<STRING>

Matriz de URIs totalmente cualificados de las ubicaciones de datos externos. Cada URI puede contener un asterisco (*) comodín, que debe ir después del nombre del depósito. Si especifica valores de uris que se dirijan a varios archivos, todos esos archivos deben compartir un esquema compatible.

En los siguientes ejemplos se muestran valores de uris válidos:

  • ['gs://bucket/path1/myfile.csv']
  • ['gs://bucket/path1/*.csv']
  • ['gs://bucket/path1/*', 'gs://bucket/path2/file00*']

En el caso de las tablas de Bigtable:

STRING

El URI que identifica la tabla de Bigtable que se va a usar como fuente de datos. Solo puedes especificar un URI de Bigtable.

Ejemplo: https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name

Para obtener más información sobre cómo crear un URI de Bigtable, consulta Obtener el URI de Bigtable.

Ejemplos

Ejemplo 1:

En el siguiente ejemplo se obtienen los tiempos de caducidad de tabla predeterminados de todas las tablas de mydataset en tu proyecto predeterminado (myproject) consultando la vista INFORMATION_SCHEMA.TABLE_OPTIONS.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, añade el ID del proyecto al conjunto de datos con el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por ejemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

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

El resultado es similar al siguiente:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

Ejemplo 2:

En el siguiente ejemplo se recuperan los metadatos de todas las tablas de mydataset que contienen datos de prueba. La consulta usa los valores de la opción description para buscar tablas que contengan "test" en cualquier parte de la descripción. mydataset está en tu proyecto predeterminado: myproject.

Para ejecutar la consulta en un proyecto que no sea el predeterminado, añade el ID del proyecto al conjunto de datos con el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view. Por ejemplo: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

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

El resultado es similar al siguiente:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

COLUMNS vista

Cuando consultas la vista INFORMATION_SCHEMA.COLUMNS, los resultados de la consulta 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 Nombre del conjunto de datos que contiene la tabla, también conocido como datasetId
TABLE_NAME STRING Nombre de la tabla o de la vista, también conocido como tableId
COLUMN_NAME STRING Nombre de la columna
ORDINAL_POSITION INT64 Desplazamiento de base 1 de la columna en la tabla. Si se trata de una pseudocolumna, como _PARTITIONTIME o _PARTITIONDATE, el valor es NULL.
IS_NULLABLE STRING YES o NO en función de si el modo de la columna permite valores NULL
DATA_TYPE STRING El tipo de datos de GoogleSQL de la columna
IS_GENERATED STRING El valor es siempre NEVER.
GENERATION_EXPRESSION STRING El valor es siempre NULL.
IS_STORED STRING El valor es siempre NULL.
IS_HIDDEN STRING YES o NO en función de si la columna es una pseudocolumna como _PARTITIONTIME o _PARTITIONDATE
IS_UPDATABLE STRING El valor es siempre NULL.
IS_SYSTEM_DEFINED STRING YES o NO en función de si la columna es una pseudocolumna como _PARTITIONTIME o _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES o NO en función de si la columna es una columna de partición
CLUSTERING_ORDINAL_POSITION INT64 Desplazamiento de la columna en la tabla, indexado a partir de 1, dentro de las columnas de agrupación en clústeres de la tabla. El valor es NULL si la tabla no es una tabla agrupada en clústeres.
COLLATION_NAME STRING Nombre de la especificación de ordenación, si existe. De lo contrario, se devuelve NULL

. Si se incluye STRING o ARRAY<STRING>, se devuelve la especificación de ordenación si existe. De lo contrario, se devuelve NULL.
COLUMN_DEFAULT STRING El valor predeterminado de la columna si existe. De lo contrario, el valor es NULL.
ROUNDING_MODE STRING El modo de redondeo que se usa para los valores escritos en el campo si su tipo es NUMERIC o BIGNUMERIC con parámetros. De lo contrario, el valor es NULL.
POLICY_TAGS ARRAY<STRING> Lista de etiquetas de política asociadas a la columna

Ejemplos

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

Como la tabla que estás consultando está en otro proyecto (bigquery-public-data), debes añadir el ID del proyecto al conjunto de datos con el siguiente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por ejemplo, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

Las siguientes columnas se excluyen de los resultados de la consulta porque actualmente están reservadas para usarlas en el futuro:

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE
  SELECT
    * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
  FROM
    `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
  WHERE
    table_name = 'population_by_zip_2010';

El resultado es similar al siguiente. Para mejorar la legibilidad, algunas columnas se han excluido del resultado.

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

COLUMN_FIELD_PATHS vista

Cuando consultas la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, los resultados de la consulta contienen una fila por cada columna anidada en 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 Nombre del conjunto de datos que contiene la tabla, también conocido como datasetId
TABLE_NAME STRING Nombre de la tabla o de la vista, también conocido como tableId
COLUMN_NAME STRING Nombre de la columna
FIELD_PATH STRING La ruta a una columna anidada en una columna `RECORD` o `STRUCT`
DATA_TYPE STRING El tipo de datos de GoogleSQL de la columna
DESCRIPTION STRING Descripción de la columna
COLLATION_NAME STRING Nombre de la especificación de ordenación si existe. De lo contrario, NULL

. Si se incluye un campo STRING, ARRAY<STRING> o STRING en un STRUCT, se devuelve la especificación de ordenación si existe. De lo contrario, se devuelve NULL.
ROUNDING_MODE STRING El modo de redondeo que se usa al aplicar precisión y escala a los valores de los parámetros NUMERIC o BIGNUMERIC. De lo contrario, el valor es NULL.
POLICY_TAGS ARRAY<STRING> Lista de etiquetas de política asociadas a la columna

Ejemplos

En el siguiente ejemplo se recuperan los metadatos de la vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS de la tabla commits del conjunto de datos github_repos. Este conjunto de datos forma parte del programa de conjuntos de datos públicos de BigQuery.

Como la tabla que estás consultando está en otro proyecto (bigquery-public-data), debes añadir el ID del proyecto al conjunto de datos con 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 repetidas:

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

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

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

El resultado es similar al siguiente. Para mejorar la legibilidad, algunas columnas se han excluido del resultado.

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

TABLE_STORAGE vista

Las vistas TABLE_STORAGE y TABLE_STORAGE_BY_ORGANIZATION tienen 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_NUMBER INT64 El número de proyecto del proyecto que contiene el conjunto de datos.
TABLE_CATALOG STRING El ID del proyecto que contiene el conjunto de datos.
TABLE_SCHEMA STRING Nombre del conjunto de datos que contiene la tabla o la vista materializada, también denominado datasetId.
TABLE_NAME STRING Nombre de la tabla o de la vista materializada, también conocido como tableId.
CREATION_TIME TIMESTAMP Hora de creación de la tabla.
TOTAL_ROWS INT64 Número total de filas de la tabla o de la vista materializada.
TOTAL_PARTITIONS INT64 Número de particiones presentes en la tabla o en la vista materializada. Las tablas sin particiones devuelven 0.
TOTAL_LOGICAL_BYTES INT64 Número total de bytes lógicos (sin comprimir) de la tabla o de la vista materializada.
ACTIVE_LOGICAL_BYTES INT64 Número de bytes lógicos (sin comprimir) que tienen menos de 90 días.
LONG_TERM_LOGICAL_BYTES INT64 Número de bytes lógicos (sin comprimir) que tienen más de 90 días.
CURRENT_PHYSICAL_BYTES INT64 Número total de bytes físicos del almacenamiento actual de la tabla en todas las particiones.
TOTAL_PHYSICAL_BYTES INT64 Número total de bytes físicos (comprimidos) usados para el almacenamiento, incluidos los bytes activos, a largo plazo y de viajes en el tiempo (datos eliminados o modificados). No se incluyen los bytes de seguridad (datos eliminados o modificados que se conservan después del periodo de la función de viaje en el tiempo).
ACTIVE_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) con una antigüedad inferior a 90 días, incluidos los bytes de viajes en el tiempo (datos eliminados o modificados).
LONG_TERM_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) con más de 90 días de antigüedad.
TIME_TRAVEL_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) usados por el almacenamiento de viajes en el tiempo (datos eliminados o modificados).
STORAGE_LAST_MODIFIED_TIME TIMESTAMP La hora más reciente en la que se escribieron datos en la tabla.
DELETED BOOLEAN Indica si la tabla se ha eliminado.
TABLE_TYPE STRING El tipo de tabla. Por ejemplo, BASE TABLE.
MANAGED_TABLE_TYPE STRING Esta columna está en versión preliminar. Tipo gestionado de la tabla. Por ejemplo, NATIVE o BIGLAKE.
FAIL_SAFE_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) utilizados por el almacenamiento a prueba de fallos (datos eliminados o modificados).
LAST_METADATA_INDEX_REFRESH_TIME TIMESTAMP La hora de la última actualización del índice de metadatos de la tabla.
TABLE_DELETION_REASON STRING Motivo de la eliminación de la tabla si el campo DELETED es true. Los valores posibles son los siguientes:
  • TABLE_EXPIRATION: tabla eliminada tras el tiempo de vencimiento establecido
  • El usuario ha eliminado el conjunto de datos DATASET_DELETION:
  • El usuario ha eliminado la tabla USER_DELETED:
TABLE_DELETION_TIME TIMESTAMP Hora de eliminación de la tabla.

Ejemplos

Ejemplo 1:

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

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

El resultado es similar al siguiente:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Ejemplo 2:

En el siguiente ejemplo se muestran los bytes de almacenamiento en GiB a nivel de conjunto de datos del proyecto actual.

SELECT
  table_schema AS dataset_name,
  -- Logical
  SUM(total_logical_bytes) / power(1024, 3) AS total_logical_gib,  
  SUM(active_logical_bytes) / power(1024, 3) AS active_logical_gib, 
  SUM(long_term_logical_bytes) / power(1024, 3) AS long_term_logical_gib, 
  -- Physical
  SUM(total_physical_bytes) / power(1024, 3) AS total_physical_gib,
  SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
  SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
  SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
  SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
  SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib 
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE 
WHERE 
  table_type ='BASE TABLE'
GROUP BY 
  table_schema  
ORDER BY 
  dataset_name 
Ejemplo 3:

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

Los precios que se usan en las variables de precios de esta consulta corresponden a la región us-central1. Si quieres ejecutar esta consulta en otra región, actualiza las variables de precios según corresponda. Para obtener información sobre los precios, consulta la sección Precio del almacenamiento.

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

    Ir a la página de BigQuery

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

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

El resultado es similar al siguiente:

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

Mostrar las tablas de un conjunto de datos

Puede enumerar las tablas de los conjuntos de datos de las siguientes formas:

  • Con la Google Cloud consola.
  • Usa el comando bq ls de la herramienta de línea de comandos bq.
  • Llamar al método de API tables.list.
  • Usar las bibliotecas de cliente.

Permisos obligatorios

Para poder enumerar las tablas de un conjunto de datos, como mínimo debes tener permisos de bigquery.tables.list. Los siguientes roles de gestión de identidades y accesos predefinidos incluyen los permisos de 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 gestión de identidades y accesos en BigQuery, consulta el artículo sobre el control de acceso.

Mostrar lista de tablas

Para mostrar las tablas de un conjunto de datos, sigue estos pasos:

Consola

  1. En la Google Cloud consola, en el panel de navegación, haz clic en tu conjunto de datos para desplegarlo. Se muestran las tablas y las vistas del conjunto de datos.

  2. Desplázate por la lista para ver las tablas del conjunto de datos. Las tablas y las vistas se identifican con iconos diferentes.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Ejecuta el comando bq ls. La marca --format se puede usar para controlar la salida. Si vas a enumerar las tablas de un proyecto que no sea el predeterminado, añade el ID del proyecto al conjunto de datos con el siguiente formato: project_id:dataset.

    Entre las marcas adicionales se incluyen las siguientes:

    • --max_results o -n: número entero que indica el número máximo de resultados. El valor predeterminado es 50.
    bq ls \
    --format=pretty \
    --max_results integer \
    project_id:dataset

    Donde:

    • integer es un número entero que representa el número de tablas que se van a enumerar.
    • project_id es el ID del proyecto.
    • dataset es el nombre del conjunto de datos.

    Cuando ejecutes el comando, el campo Type mostrará TABLE o VIEW. Por ejemplo:

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

    Ejemplos:

    Introduce el siguiente comando para ver una lista de las tablas del conjunto de datos mydataset de tu proyecto predeterminado.

       bq ls --format=pretty mydataset

    Introduce el siguiente comando para obtener más de las 50 tablas predeterminadas de mydataset. mydataset está en tu proyecto predeterminado.

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

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

       bq ls --format=pretty myotherproject:mydataset

  3. API

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

    C#

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

    Go

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    import (
    	"context"
    	"fmt"
    	"io"
    
    	"cloud.google.com/go/bigquery"
    	"google.golang.org/api/iterator"
    )
    
    // listTables demonstrates iterating through the collection of tables in a given dataset.
    func listTables(w io.Writer, projectID, datasetID string) error {
    	// projectID := "my-project-id"
    	// datasetID := "mydataset"
    	ctx := context.Background()
    	client, err := bigquery.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("bigquery.NewClient: %v", err)
    	}
    	defer client.Close()
    
    	ts := client.Dataset(datasetID).Tables(ctx)
    	for {
    		t, err := ts.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			return err
    		}
    		fmt.Fprintf(w, "Table: %q\n", t.TableID)
    	}
    	return nil
    }
    

    Java

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    import com.google.api.gax.paging.Page;
    import com.google.cloud.bigquery.BigQuery;
    import com.google.cloud.bigquery.BigQuery.TableListOption;
    import com.google.cloud.bigquery.BigQueryException;
    import com.google.cloud.bigquery.BigQueryOptions;
    import com.google.cloud.bigquery.DatasetId;
    import com.google.cloud.bigquery.Table;
    
    public class ListTables {
    
      public static void runListTables() {
        // TODO(developer): Replace these variables before running the sample.
        String projectId = "bigquery-public-data";
        String datasetName = "samples";
        listTables(projectId, datasetName);
      }
    
      public static void listTables(String projectId, String datasetName) {
        try {
          // Initialize client that will be used to send requests. This client only needs to be created
          // once, and can be reused for multiple requests.
          BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
    
          DatasetId datasetId = DatasetId.of(projectId, datasetName);
          Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
          tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));
    
          System.out.println("Tables listed successfully.");
        } catch (BigQueryException e) {
          System.out.println("Tables were not listed. Error occurred: " + e.toString());
        }
      }
    }

    Node.js

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    // Import the Google Cloud client library
    const {BigQuery} = require('@google-cloud/bigquery');
    const bigquery = new BigQuery();
    
    async function listTables() {
      // Lists tables in 'my_dataset'.
    
      /**
       * TODO(developer): Uncomment the following lines before running the sample.
       */
      // const datasetId = 'my_dataset';
    
      // List all tables in the dataset
      const [tables] = await bigquery.dataset(datasetId).getTables();
    
      console.log('Tables:');
      tables.forEach(table => console.log(table.id));
    }

    PHP

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    use Google\Cloud\BigQuery\BigQueryClient;
    
    /** Uncomment and populate these variables in your code */
    // $projectId  = 'The Google project ID';
    // $datasetId  = 'The BigQuery dataset ID';
    
    $bigQuery = new BigQueryClient([
        'projectId' => $projectId,
    ]);
    $dataset = $bigQuery->dataset($datasetId);
    $tables = $dataset->tables();
    foreach ($tables as $table) {
        print($table->id() . PHP_EOL);
    }

    Python

    Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    
    from google.cloud import bigquery
    
    # Construct a BigQuery client object.
    client = bigquery.Client()
    
    # TODO(developer): Set dataset_id to the ID of the dataset that contains
    #                  the tables you are listing.
    # dataset_id = 'your-project.your_dataset'
    
    tables = client.list_tables(dataset_id)  # Make an API request.
    
    print("Tables contained in '{}':".format(dataset_id))
    for table in tables:
        print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

    Ruby

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

    Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

    require "google/cloud/bigquery"
    
    def list_tables dataset_id = "your_dataset_id"
      bigquery = Google::Cloud::Bigquery.new
      dataset  = bigquery.dataset dataset_id
    
      puts "Tables in dataset #{dataset_id}:"
      dataset.tables.each do |table|
        puts "\t#{table.table_id}"
      end
    end

Historial de la tabla de auditoría

Puedes auditar el historial de las tablas de BigQuery consultando los registros de auditoría de Cloud en el Explorador de registros. Estos registros te ayudan a hacer un seguimiento de cuándo se crearon, actualizaron o eliminaron las tablas, así como a identificar el usuario o la cuenta de servicio que hizo los cambios.

Permisos obligatorios

Para consultar los registros de auditoría, necesitas el roles/logging.privateLogViewer rol. Para obtener más información sobre los roles y permisos de gestión de identidades y accesos en Cloud Logging, consulta el artículo sobre el control de acceso con gestión de identidades y accesos.

Obtener datos de auditoría

Puedes acceder a la información de auditoría desde la Google Cloud consolagcloud, la línea de comandos, la API REST y todos los lenguajes admitidos mediante bibliotecas de cliente. El filtro de registro que se muestra en el siguiente ejemplo se puede usar independientemente del método utilizado.

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

    Ir a Logging

  2. Usa la siguiente consulta para acceder a los datos de auditoría:

    logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity"
    AND resource.type = "bigquery_dataset"
    AND timestamp >= "STARTING_TIMESTAMP"
    AND protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog"
    AND (
      protoPayload.metadata.tableCreation :*
      OR protoPayload.metadata.tableChange :*
      OR protoPayload.metadata.tableDeletion :*
    )
    AND protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/"
    

Haz los cambios siguientes:

  • PROJECT_ID: el proyecto que contiene los conjuntos de datos y las tablas que te interesan.
  • STARTING_TIMESTAMP: los registros más antiguos que quieras ver. Usa el formato ISO 8601, como 2025-01-01 o 2025-02-03T04:05:06Z.
  • DATASET_ID: el conjunto de datos por el que quieres filtrar.

Interpretación de los resultados

En el panel de resultados del Explorador de registros, despliega la entrada que te interese y, a continuación, haz clic en Desplegar campos anidados para ver todo el mensaje.

La entrada de registro contiene solo uno de los siguientes objetos para indicar la operación realizada:

  • protoPayload.metadata.tableCreation: se ha creado una tabla.
  • protoPayload.metadata.tableChange: se han cambiado los metadatos de la tabla, como la actualización del esquema, el cambio de la descripción o la sustitución de la tabla.
  • protoPayload.metadata.tableDeletion: se ha eliminado una tabla.

El contenido de estos objetos describe la acción solicitada. Para obtener una descripción detallada, consulta BigQueryAuditMetadata.

Explicación de la consulta

  • logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity": Esta línea filtra los registros de auditoría de la actividad del administrador de tu Google Cloud proyecto. Estos registros registran las llamadas a la API y las acciones que modifican la configuración o los metadatos de tus recursos.
  • resource.type = "bigquery_dataset": acota la búsqueda a eventos relacionados con conjuntos de datos de BigQuery, donde se registran las operaciones de las tablas.
  • timestamp >= "STARTING_TIMESTAMP": filtra las entradas de registro para mostrar solo las que se crearon en la marca de tiempo especificada o después.
  • protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog": Asegura que el mensaje de registro se ajuste a la estructura estándar de los registros de auditoría de Cloud.
  • ( ... ): este bloque agrupa las condiciones para encontrar diferentes tipos de eventos de tabla, como se indica en la sección anterior. El operador :* indica que la clave debe estar presente. Si solo te interesa un evento, como la creación de una tabla, elimina las condiciones innecesarias de este bloque.
  • protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/": Selecciona las entradas de registro que coinciden con las tablas incluidas en el conjunto de datos especificado. El operador de dos puntos (:) realiza una búsqueda de subcadenas.

    • Para filtrar las entradas de una sola tabla, sustituya la condición por la siguiente: protoPayload.resourceName = "projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_NAME".
    • Para incluir todas las tablas de todos los conjuntos de datos del proyecto específico, quite esta condición.

Para obtener más información sobre el filtrado de registros, consulta el lenguaje de consultas de registro.

Seguridad de las tablas

Para controlar el acceso a las tablas de BigQuery, consulta el artículo sobre cómo controlar el acceso a los recursos con la gestión de identidades y accesos.

Siguientes pasos

Pruébalo

Si es la primera vez que utilizas Google Cloud, crea una cuenta para evaluar el rendimiento de BigQuery en situaciones reales. Los nuevos clientes también reciben 300 USD en crédito gratuito para ejecutar, probar y desplegar cargas de trabajo.

Probar BigQuery gratis