Criar e usar tabelas

Este documento descreve como criar e usar tabelas padrão (integradas) no BigQuery. Para informações sobre como criar outros tipos de tabelas, consulte:

Depois de criar uma tabela, você pode:

  • controlar o acesso aos dados de sua tabela;
  • receber informações sobre suas tabelas;
  • listar as tabelas em um conjunto de dados;
  • Receber metadados de tabela

Para mais informações sobre como gerenciar tabelas, incluindo atualização de propriedades, cópia e exclusão de tabelas, consulte Como gerenciar tabelas.

Antes de começar

Antes de criar uma tabela no BigQuery:

Nomenclatura de tabelas

Ao criar uma tabela no BigQuery, o nome dela precisa ser exclusivo para cada conjunto de dados. Esse nome pode:

  • conter até 1.024 caracteres;
  • conter caracteres Unicode na categoria L (letra), M (marca), N (número), Pc (conector, inclusive sublinhado), Pd (travessão), Zs (espaço). Para mais informações, consulte Categoria geral.

Por exemplo, os nomes de tabela a seguir são válidos: table 01, ग्राहक, 00_お客様, étudiant-01.

Alguns nomes de tabelas e prefixos de nome de tabela são reservados. Se você receber um erro informando que o nome ou o prefixo da tabela está reservado, selecione um nome diferente e tente novamente.

crie tabelas

É possível criar uma tabela no BigQuery:

  • usando manualmente o console do Cloud ou o comando bq mk da ferramenta de linha de comando bq;
  • programaticamente, chamando o método da API tables.insert;
  • usando as bibliotecas de cliente;
  • a partir dos resultados da consulta;
  • definindo uma tabela que faz referência a uma fonte de dados externa;
  • ao carregar dados;
  • Usando uma instrução de linguagem de definição de dados (DDL, na sigla em inglês) CREATE TABLE.

Permissões necessárias

Para criar uma tabela, você precisa das seguintes permissões do IAM:

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

Além disso, é possível exigir a permissão bigquery.tables.getData para acessar os dados gravados na tabela.

Cada um dos papéis predefinidos do IAM a seguir inclui as permissões necessárias para atualizar uma tabela:

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin (inclui a permissão bigquery.jobs.create)
  • roles/bigquery.user (inclui a permissão bigquery.jobs.create)
  • roles/bigquery.jobUser (inclui a permissão bigquery.jobs.create)

Além disso, se você tiver a permissão bigquery.datasets.create, será possível criar e atualizar tabelas nos conjuntos de dados que criar.

Para mais informações sobre os papéis e as permissões do IAM no BigQuery, consulte Papéis e permissões predefinidos.

Para criar uma tabela vazia com definição de esquema, faça o seguinte:

É possível criar uma tabela vazia com uma definição de esquema das seguintes maneiras:

  • inserir o esquema usando o console do Cloud;
  • fornecer o esquema in-line usando a ferramenta de linha de comando bq;
  • usar a ferramenta de linha de comando bq para enviar um arquivo de esquema JSON;
  • fornecer o esquema em um recurso de tabela ao chamar o método tables.insert da API.

Para mais informações sobre como especificar um esquema de tabela, consulte Como especificar um esquema.

Após a criação da tabela, é possível carregar dados nela ou preenchê-la gravando resultados da consulta.

Para criar uma tabela vazia com definição de esquema, faça o seguinte:

Console

  1. No console do Cloud, abra a página do BigQuery.

    Ir para o BigQuery

  2. No painel Explorer, expanda o projeto e selecione um conjunto de dados.

  3. Expanda a opção Ações e clique em Abrir.

  4. No painel de detalhes, clique em Criar tabela .

  5. Na página Criar tabela, na seção Origem, selecione Tabela vazia.

  6. Na página Criar tabela, na seção Destino:

    • Em Nome do conjunto de dados, escolha o conjunto de dados apropriado.

      Selecionar conjunto de dados

    • No campo Nome da tabela, insira o nome da tabela que você está criando no BigQuery.

    • Verifique se Tipo de tabela está definido como Tabela nativa.

  7. Na seção Esquema, insira a definição do esquema.

    • Insira as informações do esquema manualmente:

      • Ative Editar como texto e insira o esquema da tabela como uma matriz JSON.

      • Use Adicionar campo para inserir manualmente o esquema.

  8. Em Configurações de partição e cluster, use o valor padrão No partitioning.

  9. Na seção Opções avançadas, para Criptografia, use o valor padrão Google-managed key. Por padrão, o BigQuery criptografa o conteúdo do cliente armazenado em repouso.

  10. Selecione Criar tabela.

SQL

Com as instruções de linguagem de definição de dados (DDL), é possível criar e modificar tabelas e visualizações usando a sintaxe de consulta do SQL padrão.

Saiba mais sobre Como usar as instruções da linguagem de definição de dados.

Para criar uma tabela no console do Cloud usando uma instrução DDL, siga estas instruções:

  1. No console do Cloud, abra a página do BigQuery.

    Ir para o BigQuery

  2. Clique em Escrever nova consulta.

  3. Digite a instrução CREATE TABLEDDL na área de texto do editor de consulta.

    A consulta a seguir cria uma tabela chamada newtable que expira em 1º de janeiro de 2023. A descrição da tabela é "a table that expires in 2023" e o rótulo é org_unit:development.

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

  4. Opcional: clique em Mais e selecione Configurações de consulta. Configurações de consulta

  5. Opcional: em Local de processamento, clique em Seleção automática e escolha o local dos seus dados. Se você deixar o local de processamento definido como não especificado, ele será detectado automaticamente. Local de processamento da consulta

  6. Clique em Executar. Quando a consulta for concluída, a tabela será exibida no painel Recursos.

bq

Use o comando bq mk com a sinalização --table ou -t. Você pode fornecer informações de esquema de tabela in-line ou por meio de um arquivo JSON. Parâmetros opcionais incluem:

  • --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 e --destination_kms_key não são demonstrados aqui. Consulte os links a seguir para ver mais informações sobre esses parâmetros opcionais:

Se você estiver criando uma tabela em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

Para criar uma tabela vazia em um conjunto de dados existente com uma definição de esquema, insira o seguinte:

bq mk \
--table \
--expiration integer \
--description description \
--label key_1:value_1 \
--label key_2:value_2 \
project_id:dataset.table \
schema

Substitua:

  • integer é a vida útil padrão da tabela em segundos. O valor mínimo é de 3.600 segundos (uma hora). O prazo de validade é a soma do horário UTC atual com o valor inteiro. Quando você define um prazo de validade ao criar a tabela, a configuração de expiração da tabela padrão do conjunto de dados é ignorada;
  • description é uma descrição da tabela entre aspas.
  • key_1:value_1 e key_2:value_2 são pares de chave-valor que especificam rótulos.
  • project_id é o ID do projeto.
  • dataset é um conjunto de dados no projeto;
  • table é o nome da tabela que você está criando;
  • schema é uma definição de esquema in-line no formato field:data_type,field:data_type ou o caminho para o arquivo de esquema JSON na máquina local.

Quando você especifica o esquema na linha de comando, não é possível incluir um tipo RECORD (STRUCT), uma descrição de coluna nem especificar o modo da coluna. Todos os modos assumem NULLABLE como padrão. Para incluir descrições, modos e tipos RECORD, forneça um arquivo de esquema JSON.

Exemplos:

Digite o comando a seguir para criar uma tabela usando uma definição de esquema in-line. Esse comando cria uma tabela denominada mytable em mydataset no projeto padrão. A expiração da tabela é configurada para 3.600 segundos (uma hora), a descrição é definida como This is my table e o rótulo, como organization:development. O comando usa o atalho -t em vez de --table. O esquema é especificado in-line 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

Digite o comando a seguir para criar uma tabela usando um arquivo de esquema JSON. Esse comando cria uma tabela denominada mytable em mydataset no projeto padrão. A expiração da tabela é configurada para 3.600 segundos (uma hora), a descrição é definida como This is my table e o rótulo, como organization:development. O caminho para o arquivo de esquema é /tmp/myschema.json.

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

Digite o comando a seguir para criar uma tabela usando um arquivo de esquema JSON. Esse comando cria uma tabela denominada mytable em mydataset em myotherproject. A expiração da tabela é configurada para 3.600 segundos (uma hora), a descrição é definida como This is my table e o rótulo, como organization:development. O caminho para o arquivo de esquema é /tmp/myschema.json.

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

Após a criação da tabela, é possível atualizar a expiração, a descrição e os rótulos da tabela. É possível também modificar a definição do esquema.

API

Chame o método tables.insert com um recurso de tabela definido.

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em C#.


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

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

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

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 testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

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

public class CreateTable {

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

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

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

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

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

// 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 testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.

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 testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.

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 testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de Referência da API BigQuery Ruby.

require "google/cloud/bigquery"

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

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

  puts "Created table: #{table_id}"
end

Para criar uma tabela vazia sem definição de esquema:

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

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

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

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

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

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

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

Criar uma tabela usando um resultado de consulta

Para criar uma tabela com base no resultado de uma consulta, grave-o em uma tabela de destino.

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. No painel Explorer, expanda o projeto e selecione um conjunto de dados.

  3. Insira uma consulta SQL válida.

  4. Clique em Mais e selecione Configurações de consulta.

    Configurações de consulta

  5. Selecione a opção Definir uma tabela de destino para os resultados da consulta.

    Definir destino

  6. Na seção Destino, selecione o Conjunto de dados em que você quer criar a tabela e escolha um ID de tabela.

  7. Na seção Preferência de gravação na tabela de destino, escolha uma das seguintes opções:

    • Gravar apenas se a tabela estiver vazia: grava os resultados da consulta na tabela apenas se ela estiver vazia.
    • Anexar à tabela: anexa os resultados da consulta a uma tabela atual.
    • Substituir tabela: usa os resultados da consulta para substituir uma tabela atual com o mesmo nome.
  8. Opcional: em Local dos dados, escolha o local.

  9. Para atualizar as configurações de consulta, clique em Salvar.

  10. Clique em Executar. Isso cria um job de consulta que grava os resultados da consulta na tabela que você especificou.

Como alternativa, se você esquecer de especificar uma tabela de destino antes de executar a consulta, clique no botão Salvar resultados acima do editor para copiar a tabela de resultados em cache para uma tabela permanente.

SQL

Com as instruções de linguagem de definição de dados (DDL), é possível criar e modificar tabelas usando a sintaxe de consulta do SQL padrão.

Por exemplo, a instrução a seguir cria uma nova tabela chamada trips a partir de dados na tabela bikeshare_trips pública:

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

Para mais informações, consulte a página de instrução CREATE TABLE e o exemplo CREATE TABLE: Como criar uma nova tabela a partir de uma atual.

bq

Insira o comando bq query e especifique a sinalização --destination_table para criar uma tabela permanente com base nos resultados da consulta. Especifique a sinalização use_legacy_sql=false para usar a sintaxe SQL padrão. Para gravar os resultados da consulta em uma tabela que não esteja em seu projeto padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: project_id:dataset.

Opcional: forneça a sinalização --location e defina o valor para seu local.

Para controlar a disposição de gravação de uma tabela de destino atual, especifique uma das seguintes sinalizações opcionais:

  • --append_table: se a tabela de destino existir, os resultados da consulta serão anexados a ela.
  • --replace: se a tabela de destino existir, ela será substituída pelos resultados da consulta.
bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

Substitua:

  • location é o nome do local usado para processar a consulta. A sinalização --location é opcional. Por exemplo, se estiver usando o BigQuery na região de Tóquio, é possível definir o valor da sinalização como asia-northeast1. É possível definir um valor padrão para o local usando o arquivo .bigqueryrc.
  • project_id é o ID do projeto.
  • dataset é o nome do conjunto de dados que contém a tabela na qual você está gravando os resultados da consulta.
  • table é o nome da tabela na qual você está gravando os resultados da consulta.
  • query é uma consulta na sintaxe SQL padrão.

Se nenhuma sinalização de disposição de gravação for especificada, o comportamento padrão será gravar os resultados na tabela somente se ela estiver vazia. Se a tabela existir e não estiver vazia, o seguinte erro será retornado: "BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table".

Exemplos:

Digite o comando a seguir para gravar resultados de consulta em uma tabela de destino chamada mytable em mydataset. O conjunto de dados está no projeto padrão. Como nenhuma sinalização de disposição de gravação está especificada no comando, a tabela precisa ser nova ou estar vazia. Caso contrário, é retornado um erro Already exists. A consulta recupera dados do conjunto de dados público USA Name Data (link em inglês).

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'

Digite o comando a seguir para usar resultados da consulta e substituir uma tabela de destino chamada mytable em mydataset. O conjunto de dados está no projeto padrão. O comando usa a sinalização --replace para substituir a tabela 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'
 

Digite o comando a seguir para anexar resultados de consulta a uma tabela de destino chamada mytable em mydataset. O conjunto de dados está em my-other-project, e não no projeto padrão. O comando usa a sinalização --append_table para anexar os resultados da consulta na tabela 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'
 

A saída de cada um desses exemplos será semelhante ao seguinte. Para facilitar a leitura, ocultamos parte do resultado.

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

API

Para salvar resultados de consulta em uma tabela permanente, chame o método jobs.insert, configure um job query e inclua um valor para a property destinationTable. Para controlar a disposição de gravação de uma tabela de destino atual, configure a property writeDisposition.

Para controlar o local de processamento do job de consulta, especifique a property location na seção jobReference do recurso do job.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

import (
	"context"
	"fmt"
	"io"

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

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

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

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

Para salvar os resultados de consulta em uma tabela permanente, defina a tabela de destino como o TableId desejado em uma 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 testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

// 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 testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.

Para salvar resultados de consulta em uma tabela permanente, crie um QueryJobConfig e defina o destino como a TableReference desejada. Transmita a configuração do job para o método de consulta (links em inglês).
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))

: uma tabela que faz referência a uma fonte de dados externa

Uma fonte de dados externa pode ser consultada diretamente no BigQuery, mesmo que os dados não estejam no armazenamento do BigQuery.

O BigQuery é compatível com as seguintes fontes de dados externas:

Para mais informações, consulte Introdução às fontes de dados externas.

Como criar uma tabela ao carregar dados

Ao carregar dados no BigQuery, é possível: carregá-los a uma tabela ou partição nova, anexá-los a uma tabela ou partição ou substituir a tabela ou partição. Não é necessário criar uma tabela vazia antes de carregar dados nela. Você pode criar a nova tabela e carregar seus dados ao mesmo tempo.

Ao carregar dados no BigQuery, forneça o esquema de tabela ou partição. Para formatos de dados compatíveis, use a detecção automática de esquema.

Para mais informações sobre como carregar dados no BigQuery, acesse este link.

Controlar o acesso a tabelas

Para configurar o acesso a tabelas e visualizações, conceda um papel do IAM a uma entidade nos seguintes níveis, listados em ordem de intervalo de recursos permitidos (do maior para o menor):

Também é possível restringir o acesso a dados nas tabelas usando os métodos a seguir:

O acesso a qualquer recurso protegido pelo IAM é aditivo. Por exemplo, se uma entidade não tiver acesso no nível alto, como o projeto, uma opção será conceder à entidade o acesso no nível do conjunto de dados, e ela terá acesso às tabelas e visualizações no conjunto de dados. Da mesma forma, se a entidade não tiver nível acesso alto ou ao conjunto de dados, você tem a opção de conceder acesso à tabela/visualização.

A concessão de papéis do IAM em um nível mais alto na hierarquia de recursos do Google Cloud, como projeto, pasta ou organização, concede à entidade acesso a um amplo conjunto de recursos. Por exemplo, conceder um papel a uma entidade no nível do projeto fornece a ela permissões referentes aos conjuntos de dados em todo o projeto.

Conceder um papel no nível do conjunto de dados especifica as operações que uma entidade tem permissão de realizar em tabelas e define as visualizações nesse conjunto de dados específico, mesmo que a entidade não tenha acesso em um nível superior. Para informações sobre como configurar controles de acesso no nível do conjunto de dados, consulte este link.

A concessão de um papel no nível da tabela ou da visualização especifica as operações que uma entidade pode realizar em tabelas e visualizações específicas, mesmo que a entidade não tenha acesso em um nível superior. Para informações sobre como configurar controles de acesso no nível da tabela e da visualização, consulte este link.

Você também pode criar papéis personalizados do IAM. Se você criar um papel personalizado, as permissões concedidas dependerão das operações específicas que a entidade poderá executar.

Não é possível definir uma permissão "deny" em nenhum recurso protegido pelo IAM.

Para mais informações sobre papéis e permissões, consulte Noções básicas sobre papéis na documentação do IAM e os papéis e permissões do IAM do BigQuery.

Ver informações sobre tabelas

É possível conseguir informações ou metadados sobre tabelas das seguintes maneiras:

  • Como usar o console do Cloud
  • Como usar o comando bq da ferramenta de linha de comando bq show.
  • Chamada do método de API tables.get
  • usando bibliotecas de cliente.
  • consulte as visualizações INFORMATION_SCHEMA (Beta);

Permissões necessárias

Para ver informações sobre tabelas, é preciso ter pelo menos as permissões bigquery.tables.get. Os seguintes papéis predefinidos do IAM incluem as permissões bigquery.tables.get:

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

Além disso, quando um usuário tem permissões bigquery.datasets.create e cria um conjunto de dados, ele recebe o acesso bigquery.dataOwner ao conjunto. O acesso bigquery.dataOwner permite que o usuário recupere metadados da tabela.

Para mais informações sobre papéis e permissões do IAM no BigQuery, consulte Controle de acesso.

Receber informações de tabelas

Para ver informações sobre tabelas:

Console

  1. Na seção Recursos do painel de navegação, amplie o projeto e selecione um conjunto de dados. Clique no nome do conjunto de dados para expandi-lo. Isso exibe as tabelas e visualizações no conjunto de dados.

  2. Clique no nome da tabela.

  3. Abaixo do editor, clique em Detalhes. Essa página exibe a descrição e as informações da tabela.

  4. Clique na guia Schema para ver a definição do esquema da tabela.

bq

Emita o comando bq show para exibir todas as informações da tabela. Use a sinalização --schema para exibir somente informações de esquema da tabela. É possível usar a sinalização --format para controlar a saída.

Se você estiver recebendo informações sobre uma tabela em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

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

Em que:

  • project_id é o ID do projeto;
  • dataset é o nome do conjunto de dados.
  • table é o nome da tabela.

Exemplos:

Digite o comando a seguir para exibir todas as informações sobre mytable em mydataset. mydataset está em seu projeto padrão.

bq show --format=prettyjson mydataset.mytable

Digite o comando a seguir para exibir todas as informações sobre mytable em mydataset. mydataset está em myotherproject, e não no seu projeto padrão.

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

Digite o comando a seguir para exibir apenas informações de esquema sobre mytable em mydataset. mydataset está em myotherproject, não no projeto padrão.

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

API

Chame o método tables.get e forneça os parâmetros relevantes.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

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 testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

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

public class GetTable {

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

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

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

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

// 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 testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.

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 testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.


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

Receber informações de tabela usando INFORMATION_SCHEMA

INFORMATION_SCHEMA é uma série de visualizações que fornecem acesso a metadados sobre conjuntos de dados, rotinas, tabelas, visualizações, jobs, reservas e dados de streaming.

Consulte as seguintes visualizações para acessar informações da tabela:

  • Use as visualizações INFORMATION_SCHEMA.TABLES e INFORMATION_SCHEMA.TABLE_OPTIONS para recuperar metadados sobre tabelas e visualizações em um projeto.
  • Use as visualizações INFORMATION_SCHEMA.COLUMNS e INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para recuperar metadados sobre as colunas (campos) de uma tabela.
  • Use as visualizações INFORMATION_SCHEMA.TABLE_STORAGE e INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_* para recuperar metadados sobre o uso de armazenamento atual e histórico de uma tabela.

As visualizações TABLES e TABLE_OPTIONS também contêm informações de alto nível sobre visualizações. Para ver informações detalhadas, consulte a visualização INFORMATION_SCHEMA.VIEWS.

Visualização TABLES

Os resultados das consultas na visualização INFORMATION_SCHEMA.TABLES contêm uma linha para cada tabela ou visualização do conjunto de dados. Para informações detalhadas sobre visualizações, consulte a visualização INFORMATION_SCHEMA.VIEWS.

A visualização INFORMATION_SCHEMA.TABLES tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
table_catalog STRING O ID do projeto que contém o conjunto de dados.
table_schema STRING O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId.
table_name STRING O nome da tabela ou visualização, também conhecido como tableId.
table_type STRING O tipo de tabela, que pode ser:
is_insertable_into STRING YES ou NO dependendo da compatibilidade da tabela com as instruções DML INSERT
is_typed STRING O valor sempre é NO.
creation_time TIMESTAMP O horário de criação da tabela
ddl STRING A instrução DDL que pode ser usada para recriar a tabela, como CREATE TABLE ou CREATE VIEW
clone_time TIMESTAMP Para clones de tabelas (visualização), a hora em que a tabela base foi clonada para criar a tabela. Se a viagem no tempo foi usada, esse campo vai conter o carimbo de data/hora da viagem. Caso contrário, o campo clone_time será igual ao campo creation_time. Aplicável apenas a tabelas com table_type definido como CLONE.
base_table_catalog STRING Para clones de tabelas (visualização), o projeto da tabela base. Aplicável apenas a tabelas com table_type definido como CLONE.
base_table_schema STRING Para clones de tabelas (visualização), o conjunto de dados da tabela base. Aplicável apenas a tabelas com table_type definido como CLONE.
base_table_name STRING Para clones de tabelas (visualização), o nome da tabela base. Aplicável apenas a tabelas com table_type definido como CLONE.
default_collation_name STRING Nome da especificação de compilação padrão, se houver. Caso contrário, NULL.

Examples

Exemplo 1:

O exemplo a seguir recupera metadados de tabela para todas as tabelas no conjunto de dados chamado mydataset. A consulta seleciona todas as colunas da visualização INFORMATION_SCHEMA.TABLES, exceto is_typed, que é reservada para uso futuro, e ddl, que está oculta das consultas SELECT *. Os metadados retornados correspondem a todas as tabelas em mydataset no projeto padrão.

mydataset contém as seguintes tabelas:

  • mytable1: uma tabela padrão do BigQuery
  • myview1: uma visualização do BigQuery

Para executar a consulta em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view. Veja um exemplo: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    
  3. Clique em Executar.

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.

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

O exemplo a seguir recupera todas as tabelas do tipo BASE TABLE da visualização INFORMATION_SCHEMA.TABLES. A coluna is_typed é excluída e a coluna ddl está oculta. Os metadados retornados são para tabelas em mydataset no projeto padrão.

Para executar a consulta em um projeto diferente do padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por exemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.

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

Exemplo 3:

O exemplo a seguir recupera colunas table_name e ddl da visualização INFORMATION_SCHEMA.TABLES para a tabela population_by_zip_2010 no conjunto de dados census_bureau_usa. Esse conjunto de dados faz parte do programa de conjunto de dados públicos do BigQuery.

Como a tabela que você está consultando está em outro projeto, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view. Neste exemplo, o valor é `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão o seguinte formato:

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       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", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  

Visualização TABLE_OPTIONS

Os resultados das consultas na visualização INFORMATION_SCHEMA.TABLE_OPTIONS contêm uma linha para cada opção, para cada tabela ou visualização do conjunto de dados. Para informações detalhadas sobre visualizações, consulte a visualização INFORMATION_SCHEMA.VIEWS.

A visualização INFORMATION_SCHEMA.TABLE_OPTIONS tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
TABLE_CATALOG STRING O ID do projeto que contém o conjunto de dados
TABLE_SCHEMA STRING O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou visualização, também conhecido como tableId
OPTION_NAME STRING Um dos valores de nome na tabela opções.
OPTION_TYPE STRING Um dos valores de tipo de dados na tabela de opções.
OPTION_VALUE STRING Uma das opções de valor na tabela de opções.
Tabela de opções
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 A vida útil padrão, em dias, de todas as partições em uma tabela particionada
expiration_timestamp FLOAT64 A hora em que esta tabela expira
kms_key_name STRING O nome da chave do Cloud KMS usada para criptografar a tabela
friendly_name STRING O nome descritivo da tabela.
description STRING Uma descrição da tabela
labels ARRAY<STRUCT<STRING, STRING>> Uma matriz de STRUCTs que representa as identificações na tabela
require_partition_filter BOOL Se as consultas na tabela exigem um filtro de partição
enable_refresh BOOL Se a atualização automática está ativada para uma visualização materializada.
refresh_interval_minutes FLOAT64 Com que frequência uma visualização materializada é atualizada

Em tabelas externas, as seguintes opções podem ser usadas:

Opções
allow_jagged_rows

BOOL

Se true, permita linhas que não têm colunas opcionais posteriores.

Aplica-se a dados CSV.

allow_quoted_newlines

BOOL

Se true, permita seções de dados entre aspas que contenham caracteres de nova linha no arquivo.

Aplica-se a dados CSV.

compression

STRING

O tipo de compactação da fonte de dados. Os valores aceitos são: GZIP. Se não for especificada, a fonte de dados será descompactada.

Aplica-se a dados CSV e JSON.

description

STRING

Uma descrição da tabela.

enable_logical_types

BOOL

Se true, converta tipos lógicos Avro nos tipos SQL correspondentes. Para mais informações, consulte Tipos lógicos.

Aplica-se a dados Avro.

encoding

STRING

A codificação de caracteres dos dados. Os valores aceitos incluem: UTF8 (ou UTF-8), ISO_8859_1 (ou ISO-8859-1).

Aplica-se a dados CSV.

expiration_timestamp

TIMESTAMP

A hora em que esta tabela expira. Se não for especificado, a tabela não expirará.

Exemplo: "2025-01-01 00:00:00 UTC".

field_delimiter

STRING

O separador de campos em um arquivo CSV.

Aplica-se a dados CSV.

format

STRING

O formato dos dados externos. Os valores aceitos são: AVRO, CSV, DATASTORE_BACKUP, GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (ou JSON), ORC, PARQUET.

O valor JSON é equivalente a NEWLINE_DELIMITED_JSON.

decimal_target_types

ARRAY<STRING>

Determina como converter um tipo Decimal. Equivalente a ExternalDataConfiguration.decimal_target_types

Exemplo: ["NUMERIC", "BIGNUMERIC"].

json_extension

STRING

Para dados JSON, indica um determinado formato de intercâmbio JSON. Se não for especificado, o BigQuery lerá os dados como registros JSON genéricos.

Os valores aceitos são:
GEOJSON. Dados GeoJSON delimitados por nova linha. Para mais informações, consulte Como criar uma tabela externa a partir de um arquivo GeoJSON delimitado por nova linha.

hive_partition_uri_prefix

STRING

Um prefixo comum para todos os URIs de origem antes do início da codificação da chave de partição. Aplica-se apenas a tabelas externas particionadas pelo Hive.

Aplica-se aos dados Avro, CSV, JSON, Parquet e ORC.

Exemplo: "gs://bucket/path".

ignore_unknown_values

BOOL

Se for true, ignora valores extras que não estejam representados no esquema da tabela, sem retornar um erro.

Aplica-se a dados CSV e JSON.

max_bad_records

INT64

O número máximo de registros corrompidos a serem ignorados durante a leitura dos dados.

Aplica-se a: dados CSV, JSON e Planilhas.

null_marker

STRING

A string que representa os valores NULL em um arquivo CSV.

Aplica-se a dados CSV.

projection_fields

STRING

Uma lista de propriedades da entidade a serem carregadas.

Aplica-se aos dados do Datastore.

quote

STRING

A string usada para citar seções de dados em um arquivo CSV. Se os dados contiverem caracteres de nova linha entre aspas, defina também a propriedade allow_quoted_newlines como true.

Aplica-se a dados CSV.

require_hive_partition_filter

BOOL

Se true, todas as consultas nesta tabela exigem um filtro de partição que pode ser usado para eliminar partições ao ler dados. Aplica-se apenas a tabelas externas particionadas pelo Hive.

Aplica-se aos dados Avro, CSV, JSON, Parquet e ORC.

sheet_range

STRING

Intervalo de uma planilha do Planilhas a ser consultada.

Aplicável aos dados do Planilhas.

Exemplo: “sheet1!A1:B20”,

skip_leading_rows

INT64

O número de linhas na parte superior de um arquivo a ser ignorado na leitura dos dados.

Aplicável aos dados CSV e Planilhas.

uris

ARRAY<STRING>

Uma matriz de URIs totalmente qualificados para os locais de dados externos.

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

Exemplos

Exemplo 1:

O exemplo a seguir recupera os prazos de validade da tabela padrão para todas as tabelas em mydataset no seu projeto padrão (myproject) consultando a visualização INFORMATION_SCHEMA.TABLE_OPTIONS.

Para executar a consulta em um projeto diferente do projeto padrão, adicione o código do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view. Veja um exemplo: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="expiration_timestamp"
    
  3. Clique em Executar.

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão o seguinte formato:

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

Exemplo 2:

O exemplo a seguir recupera os metadados sobre todas as tabelas em mydataset que contêm dados de teste. A consulta usa os valores da opção description para encontrar tabelas que contenham "teste" em qualquer parte da descrição. mydataset está no projeto padrão (myproject).

Para executar a consulta em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view (por exemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS).

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão o seguinte formato:

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

Visualização COLUMNS

Os resultados das consultas na visualização INFORMATION_SCHEMA.COLUMNS contêm uma linha para cada coluna (campo) da tabela.

A visualização INFORMATION_SCHEMA.COLUMNS tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
TABLE_CATALOG STRING O ID do projeto que contém o conjunto de dados
TABLE_SCHEMA STRING O nome do conjunto de dados que contém a tabela, também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou visualização, também conhecido como tableId
COLUMN_NAME STRING O nome da coluna
ORDINAL_POSITION INT64 O deslocamento de índice 1 da coluna na tabela. Se for uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE, o valor será NULL
IS_NULLABLE STRING YES ou NO, dependendo do modo da coluna permitir valores NULL
DATA_TYPE STRING O tipo de dados SQL padrão da coluna
IS_GENERATED STRING O valor sempre é NEVER.
GENERATION_EXPRESSION STRING O valor sempre é NULL
IS_STORED STRING O valor sempre é NULL.
IS_HIDDEN STRING YES ou NO, dependendo do tipo de coluna (se é ou não é uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE)
IS_UPDATABLE STRING O valor sempre é NULL.
IS_SYSTEM_DEFINED STRING YES ou NO, dependendo do tipo de coluna (se é ou não é uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE)
IS_PARTITIONING_COLUMN STRING YES ou NO dependendo se a coluna é uma coluna de particionamento ou não
CLUSTERING_ORDINAL_POSITION INT64 O deslocamento de índice 1 da coluna nas colunas de cluster da tabela. O valor será NULL se a tabela não for uma tabela em cluster
COLLATION_NAME STRING Nome da especificação da compilação, se ela existir; Caso contrário, NULL

Se um STRING ou ARRAY<STRING> for transmitido, a especificação de compilação será retornada, se existir; Caso contrário, NULL é retornado.

Examples

O exemplo a seguir recupera metadados da visualização INFORMATION_SCHEMA.COLUMNS para a tabela population_by_zip_2010 no conjunto de dados census_bureau_usa. Ele faz parte do programa de conjunto de dados públicos do BigQuery.

Como a tabela que você está consultando está em outro projeto, bigquery-public-data, adicione o código do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por exemplo, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

As colunas a seguir são excluídas dos resultados da consulta porque atualmente estão reservadas para uso futuro:

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.

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

Visualização COLUMN_FIELD_PATHS

Os resultados das consultas na visualização INFORMATION_SCHEMA.COLUMN_FIELD_PATHS contêm uma linha para cada coluna aninhada dentro de uma coluna RECORD (ou STRUCT).

A visualização INFORMATION_SCHEMA.COLUMN_FIELD_PATHS tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
TABLE_CATALOG STRING O ID do projeto que contém o conjunto de dados
TABLE_SCHEMA STRING O nome do conjunto de dados que contém a tabela, também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou visualização, também conhecido como tableId
COLUMN_NAME STRING O nome da coluna
FIELD_PATH STRING O caminho para uma coluna aninhada em uma coluna `RECORD` ou `STRUCT`.
DATA_TYPE STRING O tipo de dados SQL padrão da coluna.
DESCRIPTION STRING A descrição da coluna
COLLATION_NAME STRING Nome da especificação da compilação, se ela existir; Caso contrário, NULL

Se um campo STRING, ARRAY<STRING> ou STRING em um STRUCT for transmitido, a especificação de compilação será retornada, se existir. Caso contrário, NULL é retornado.

Examples

O exemplo a seguir recupera metadados da visualização INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para a tabela commits no conjunto de dados github_repos. Ele faz parte do programa de conjunto de dados públicos do BigQuery.

Como a tabela que você está consultando está em outro projeto, bigquery-public-data, adicione o código do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view; por exemplo, `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

A tabela commits contém as seguintes colunas aninhadas e repetidas ou só aninhadas:

  • author: coluna RECORD aninhada
  • committer: coluna RECORD aninhada
  • trailer: coluna RECORD aninhada e repetida
  • difference: coluna RECORD aninhada e repetida

A consulta vai recuperar os metadados sobre as colunas author e difference.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.

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

Visualização TABLE_STORAGE

A visualização INFORMATION_SCHEMA.TABLE_STORAGE fornece um snapshot atual do uso do armazenamento das tabelas e visualizações materializadas. Quando você consulta a visualização INFORMATION_SCHEMA.TABLE_STORAGE, os resultados da consulta contêm uma linha para cada tabela ou visualização materializada. Os dados dessa tabela não são mantidos em tempo real e podem atrasar de alguns segundos a alguns minutos.

Os dados da visualização são regionalizados. Portanto, é necessário usar um qualificador de região em consultas na visualização. O projeto padrão será usado se você não especificar um.

Os exemplos a seguir mostram como retornar dados de um projeto ou região.

Retorna informações de armazenamento de tabelas em um projeto especificado:

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

Retorna informações de armazenamento de tabelas em uma região especificada:

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

A visualização INFORMATION_SCHEMA.TABLE_STORAGE tem o seguinte esquema:

Nome da coluna Tipo de dados Valor
PROJECT_ID STRING O ID do projeto que contém o conjunto de dados
PROJECT_NAME INT64 O número do projeto que contém o conjunto de dados
TABLE_SCHEMA STRING O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou visualização, também conhecido como tableId
CREATION_TIME TIMESTAMP O horário de criação da tabela
TOTAL_ROWS INT64 O número total de linhas na tabela ou visualização materializada
TOTAL_PARTITIONS INT64 O número de partições presentes na tabela ou na visualização materializada. Tabelas não particionadas retornam 0.
TOTAL_LOGICAL_BYTES INT64 Número total de bytes lógicos na tabela ou visualização materializada
ACTIVE_LOGICAL_BYTES INT64 Número de bytes lógicos com menos de 90 dias
LONG_TERM_LOGICAL_BYTES INT64 Número de bytes lógicos com mais de 90 dias
TOTAL_PHYSICAL_BYTES INT64 Número total de bytes físicos usados para armazenamento, incluindo bytes ativos, de longo prazo e de viagem no tempo (para tabelas excluídas)
ACTIVE_PHYSICAL_BYTES INT64 Número de bytes físicos com menos de 90 dias
LONG_TERM_PHYSICAL_BYTES INT64 Número de bytes físicos com mais de 90 dias
TIME_TRAVEL_PHYSICAL_BYTES INT64 Número de bytes físicos usados pelo armazenamento de viagem no tempo (dados excluídos ou alterados)

Examples

O exemplo a seguir mostra quais projetos da organização estão usando mais armazenamento.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados vão ter o seguinte formato:

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

VisualizaçõesTABLE_STORAGE_TIMELINE_BY_

As visualizações da linha do tempo do armazenamento de tabela retornam uma linha para cada evento que aciona uma alteração de armazenamento, como gravação, atualização ou exclusão de uma linha. Isso significa que pode haver várias linhas para uma tabela em um único dia. Ao consultar uma visualização para um período, use o carimbo de data/hora mais recente no dia pretendido.

As seguintes visualizações de linha do tempo do armazenamento de tabelas estão disponíveis:

  • INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT retorna informações de todas as tabelas no projeto atual ou especificado.
  • INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION retorna informações de todas as tabelas na pasta pai do projeto atual ou especificado, incluindo os projetos em subpastas abaixo dele.

Os dados da visualização são regionalizados. Portanto, é necessário usar um qualificador de região em consultas na visualização.

As visualizações da linha do tempo do armazenamento da tabela têm o seguinte esquema:

Nome da coluna Tipo de dados Valor
TIMESTAMP TIMESTAMP Carimbo de data/hora do último cálculo do armazenamento. O novo cálculo é acionado por alterações nos dados da tabela.
DELETED BOOLEAN Indica se a tabela foi excluída.
PROJECT_ID STRING O ID do projeto que contém o conjunto de dados
PROJECT_NAME INT64 O número do projeto que contém o conjunto de dados
TABLE_SCHEMA STRING O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou visualização, também conhecido como tableId
CREATION_TIME TIMESTAMP O horário de criação da tabela
TOTAL_ROWS INT64 O número total de linhas na tabela ou visualização materializada
TOTAL_PARTITIONS INT64 O número de partições da tabela ou da visualização materializada. Tabelas não particionadas retornam 0.
TOTAL_LOGICAL_BYTES INT64 Número total de bytes lógicos na tabela ou visualização materializada
ACTIVE_LOGICAL_BYTES INT64 Número de bytes lógicos com menos de 90 dias
LONG_TERM_LOGICAL_BYTES INT64 Número de bytes lógicos com mais de 90 dias
TOTAL_PHYSICAL_BYTES INT64 Número total de bytes físicos usados para armazenamento, incluindo bytes ativos, de longo prazo e de viagem no tempo (para tabelas excluídas)
ACTIVE_PHYSICAL_BYTES INT64 Número de bytes físicos com menos de 90 dias
LONG_TERM_PHYSICAL_BYTES INT64 Número de bytes físicos com mais de 90 dias
TIME_TRAVEL_PHYSICAL_BYTES INT64 Número de bytes físicos usados pelo armazenamento de viagem no tempo (dados excluídos ou alterados)

Examples

Exemplo 1:

O exemplo a seguir mostra quais tabelas estão usando mais armazenamento em um conjunto de dados específico.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados terão o seguinte formato:

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

Exemplo 2:

O exemplo a seguir mostra a soma do armazenamento físico usado por cada projeto na organização em um determinado momento.

Para executar a consulta, faça o seguinte:

Console

  1. Abra a página do BigQuery no console do Cloud.

    Acesse a página do BigQuery

  2. Insira a consulta SQL padrão a seguir na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.

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

bq

Use o comando bq query e especifique a sintaxe SQL padrão usando a sinalização --nouse_legacy_sql ou --use_legacy_sql=false. A sintaxe SQL padrão é obrigatória para consultas INFORMATION_SCHEMA.

Para executar a consulta, insira:

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

Os resultados vão ter o seguinte formato:

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

Listar tabelas em um conjunto de dados

É possível listar tabelas em conjuntos de dados das seguintes maneiras:

  • Como usar o console do Cloud
  • Como usar o comando bq da ferramenta de linha de comando bq ls.
  • Chamada do método de API tables.list
  • Como usar bibliotecas de cliente.

Permissões necessárias

Para listar tabelas em um conjunto de dados, é preciso ter pelo menos as permissões bigquery.tables.list. Os seguintes papéis predefinidos do IAM incluem as permissões bigquery.tables.list:

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

Para mais informações sobre papéis e permissões do IAM no BigQuery, consulte Controle de acesso.

Listar tabelas

Para listar as tabelas em um conjunto de dados:

Console

  1. No console do Cloud, no painel de navegação, clique no conjunto de dados para expandi-lo. Isso exibe as tabelas e visualizações no conjunto de dados.

  2. Percorra a lista para ver as tabelas no conjunto de dados. Tabelas e visualizações são identificadas por ícones diferentes.

bq

Emita o comando bq ls. É possível usar a sinalização --format para controlar a saída. Se estiver listando tabelas em um projeto diferente do seu projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

Veja a seguir algumas outras sinalizações:

  • --max_results ou -n: um número inteiro que indica o valor máximo de resultados. O valor padrão é 50.
bq ls \
--format=pretty \
--max_results integer \
project_id:dataset

Em que:

  • integer é um número inteiro que representa o total de tabelas a serem listadas;
  • project_id é o ID do projeto;
  • dataset é o nome do conjunto de dados.

Quando você executa o comando, o campo Type exibe TABLE ou VIEW. Por exemplo:

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

Exemplos:

Digite o comando a seguir para listar tabelas no conjunto de dados mydataset no seu projeto padrão.

    bq ls --format=pretty mydataset

Digite o comando a seguir para retornar mais do que a saída padrão de 50 tabelas de mydataset. mydataset está em seu projeto padrão.

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

Digite o comando a seguir para listar tabelas no conjunto de dados mydataset em myotherproject.

    bq ls --format=pretty myotherproject:mydataset

API

Para listar tabelas usando a API, chame o método tables.list.

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em C#.


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 testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

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 testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

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

public class ListTables {

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

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

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

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

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

// 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 testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.

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 testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.


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 testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de Referência da API BigQuery Ruby.

require "google/cloud/bigquery"

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

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

Segurança de tabelas

Para controlar o acesso a tabelas no BigQuery, consulte Introdução aos controles de acesso a tabelas.

Próximas etapas

Faça um teste

Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho do BigQuery em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação gratuita do BigQuery