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:

• Como criar tabelas particionadas
• Como criar e usar tabelas em cluster

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:

• defina um projeto seguindo um Guia de primeiros passos do BigQuery;
• crie um conjunto de dados do BigQuery;
• se você quiser, leia Introdução a tabelas para entender as limitações, as cotas e os preços das tabelas.

Nomenclatura de tabelas

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

• Conter caracteres com um total de até 1.024 bytes UTF-8.
• 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.

Veja a seguir exemplos de nomes de tabela válidos: table 01, ग्राहक, 00_お客様 e étudiant-01.

Advertências:

• Por padrão, os nomes de tabelas diferenciam maiúsculas de minúsculas. mytable e MyTable podem coexistir no mesmo conjunto de dados, a menos que façam parte de um conjunto de dados com diferenciação de maiúsculas e minúsculas desativada.
• 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.

• Se você incluir vários operadores de ponto (.) em uma sequência, os operadores duplicados serão removidos implicitamente.

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

  Se tornaria: project_name.dataset_name.table_name

crie tabelas

É possível criar uma tabela no BigQuery:

• Manualmente, usando o Console do Google Cloud ou o comando da ferramenta de linha de comando bq bq mk.
• 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:

• Insira o esquema usando o Console do Google Cloud.
• forneça o esquema in-line usando a ferramenta de linha de comando bq;
• utilize a ferramenta de linha de comando bq para enviar um arquivo de esquema JSON;
• forneça 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 Google Cloud, acesse a página BigQuery.

   Acessar o BigQuery

2. No painel Explorer, expanda seu projeto e selecione um conjunto de dados.
3. Na seção Informações do conjunto de dados, clique em Criar tabela.
4. No painel Criar tabela, especifique os seguintes detalhes:
1. Na seção Origem, selecione Tabela vazia na lista Criar tabela de.
2. Na seção Destino, especifique os seguintes campos:
   1. Em Conjunto de dados, selecione o conjunto de dados em que você quer criar a tabela.
   2. No campo Tabela, insira o nome da tabela que você quer criar.
   3. Verifique se o campo Tipo de tabela está definido como Tabela nativa.
3. Na seção Esquema, insira a definição do esquema. É possível inserir as informações do esquema manualmente usando um dos seguintes métodos:
   • Opção 1: clique em Editar como texto e cole o esquema na forma de uma matriz JSON. Com ela, você gera o esquema usando um processo igual ao de criação de um arquivo de esquema JSON. É possível visualizar o esquema de uma tabela existente no formato JSON inserindo o seguinte comando:

         bq show --format=prettyjson dataset.table
         

   • Opção 2: clique em Adicionar campo e insira o esquema da tabela. Especifique o Nome, o Tipo e o Modo de cada campo.
4. Opcional: especifique configurações de partição e cluster. Para mais informações, consulte Como criar tabelas particionadas e Como criar e usar tabelas em cluster.
5. Opcional: na seção Opções avançadas, se você quiser usar uma chave de criptografia gerenciada pelo cliente, selecione a opção Usar uma chave de criptografia gerenciada pelo cliente (CMEK, na sigla em inglês). Por padrão, o BigQuery criptografa o conteúdo do cliente armazenado em repouso usando uma chave pertencente e gerenciada pelo Google.
6. Selecione Criar tabela.

Observação: ao criar uma tabela vazia usando o console do Cloud, não será possível adicionar um rótulo, uma descrição ou um prazo de validade. Será possível adicionar essas propriedades opcionais ao criar uma tabela usando a API ou a ferramenta de linha de comando bq. Depois de criar uma tabela no Console do Google Cloud, é possível adicionar uma validade, descrição e rótulos.

SQL

O exemplo a seguir cria uma tabela chamada newtable que expira em 1º de janeiro de 2023:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No editor de consultas, digite a seguinte instrução:

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

3. Clique em Executar.

Para mais informações sobre como executar consultas, acesse Executar uma consulta interativa.

bq

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

   Activate Cloud Shell

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

2. Utilize 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. Para obter uma lista completa de parâmetros, consulte a referência bq mk --table. Alguns 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:

   • Para mais informações sobre --time_partitioning_field, --time_partitioning_type e --range_partitioning, consulte tabelas particionadas.
   • Para mais informações sobre --clustering_fields, consulte tabelas em cluster.
   • Para mais informações sobre --destination_kms_key, consulte chaves de criptografia gerenciadas pelo cliente.

   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 \
   --add_tags=key_3:value_3[,...] \
   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.
   • key_3:value_3 são pares de chave-valor que especificam tags. Adicione várias tags na mesma sinalização usando vírgulas entre os pares de chave-valor.
   • 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.

   Ao especificar o esquema na linha de comando, não há como incluir um tipo RECORD (STRUCT) ou 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.

Terraform

Use o recurso google_bigquery_table.

Observação: para criar objetos do BigQuery usando o Terraform, é necessário ativar a API Cloud Resource Manager.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

Criar uma tabela

No exemplo a seguir, criamos uma tabela denominada mytable:

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

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

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

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

}

Criar uma tabela e conceder acesso a ela

O exemplo a seguir cria uma tabela chamada mytable e usa o recurso google_bigquery_table_iam_policy para conceder acesso a ela. Só realize esta etapa se você quiser conceder acesso à tabela aos principais que não têm acesso ao conjunto de dados em que a tabela reside.

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

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

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

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

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:[e-mail]",
    ]
  }
}

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

Criar uma tabela com uma chave de criptografia gerenciada pelo cliente

O exemplo a seguir cria uma tabela chamada mytable e também usa os recursos google_kms_crypto_key e google_kms_key_ring para especificar uma chave do Cloud Key Management Service para a tabela. É necessário ativar a API Cloud Key Management Service antes de executar este exemplo.

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

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

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

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

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

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

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

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

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

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

Para aplicar a configuração do Terraform em um projeto do Google Cloud, conclua as etapas nas seções a seguir.

Preparar o Cloud Shell

1. Inicie o Cloud Shell.

2. Defina o projeto padrão do Google Cloud em que você quer aplicar as configurações do Terraform.

   Você só precisa executar esse comando uma vez por projeto, e ele pode ser executado em qualquer diretório.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   As variáveis de ambiente serão substituídas se você definir valores explícitos no arquivo de configuração do Terraform.

Preparar o diretório

Cada arquivo de configuração do Terraform precisa ter o próprio diretório, também chamado de módulo raiz.

1. No Cloud Shell, crie um diretório e um novo arquivo dentro dele. O nome do arquivo precisa ter a extensão .tf, por exemplo, main.tf. Neste tutorial, o arquivo é chamado de main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Se você estiver seguindo um tutorial, poderá copiar o exemplo de código em cada seção ou etapa.

   Copie o exemplo de código no main.tf recém-criado.

   Se preferir, copie o código do GitHub. Isso é recomendado quando o snippet do Terraform faz parte de uma solução de ponta a ponta.

3. Revise e modifique os parâmetros de amostra para aplicar ao seu ambiente.
4. Salve as alterações.
5. Inicialize o Terraform. Você só precisa fazer isso uma vez por diretório.

   terraform init

   Opcionalmente, para usar a versão mais recente do provedor do Google, inclua a opção -upgrade:

   terraform init -upgrade

Aplique as alterações

1. Revise a configuração e verifique se os recursos que o Terraform vai criar ou atualizar correspondem às suas expectativas:

   terraform plan

   Faça as correções necessárias na configuração.

2. Para aplicar a configuração do Terraform, execute o comando a seguir e digite yes no prompt:

   terraform apply

   Aguarde até que o Terraform exiba a mensagem "Apply complete!".

3. Abra seu projeto do Google Cloud para ver os resultados. No console do Google Cloud, navegue até seus recursos na IU para verificar se foram criados ou atualizados pelo Terraform.

Observação: as amostras do Terraform geralmente presumem que as APIs necessárias estejam ativadas no projeto do Google Cloud.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

using Google.Cloud.BigQuery.V2;

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

Go

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"time"

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

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

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

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

Java

Antes de 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

public class CreateTable {

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

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

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

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

Node.js

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

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

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

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

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

PHP

Antes de 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 em PHP.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

from google.cloud import bigquery

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

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

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

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

Ruby

Antes de testar esta amostra, siga as instruções de configuração do 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 em Ruby.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

require "google/cloud/bigquery"

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

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

  puts "Created table: #{table_id}"
end

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.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

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

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

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

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

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

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

   

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

   

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

O exemplo a seguir usa a instrução CREATE TABLE para criar a tabela trips a partir de dados na tabela pública bikeshare_trips:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No editor de consultas, digite a seguinte instrução:

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

3. Clique em Executar.

Para mais informações sobre como executar consultas, acesse Executar uma consulta interativa.

Para mais informações, consulte Como criar uma nova tabela a partir de uma existente.

bq

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

   Activate Cloud Shell

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

2. 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 do GoogleSQL. 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, 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 do GoogleSQL.

     Se nenhuma flag 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 erro a seguir será retornado: BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1: Already Exists: Table project_id:dataset.table.

     Exemplos:

     Observação: nestes exemplos, consultamos um conjunto de dados públicos localizado nos EUA. Como o conjunto de dados público é armazenado no local multirregional dos EUA, o conjunto de dados que contém a tabela de destino também precisa estar nesse país. Não é possível consultar um conjunto de dados em um local e gravar os resultados em uma tabela de destino em outro local.

     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.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

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

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

Java

Antes de 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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 em Node.js.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

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

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

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

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

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

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

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

Python

Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

Para salvar resultados de consulta em uma tabela permanente, crie um QueryJobConfig e defina o destination como a TableReference desejada. Transmita a configuração do job para o método de consulta.

from google.cloud import bigquery

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

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

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

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

: 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. Por exemplo, é possível ter dados em um banco de dados diferente do Google Cloud, em arquivos no Cloud Storage ou em um produto de nuvem diferente que você quer analisar no BigQuery, mas não está preparado para a migração.

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

• Um nível alto na hierarquia de recursos do Google Cloud, como o nível do projeto, da pasta ou da organização
• O nível do conjunto de dados
• o nível da tabela ou da visualização

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

• segurança no nível da coluna
• mascaramento de dados de coluna
• segurança no nível da linha

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:

• Usando o Console do Google Cloud.
• usando o comando bq show da ferramenta de linha de comando bq;
• chamando o 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, expanda o projeto e selecione um conjunto de dados.

2. Clique no nome do conjunto de dados para expandi-lo. As tabelas e as visualizações no conjunto de dados são exibidas.

3. Clique no nome da tabela.

4. No painel Detalhes, clique em Detalhes para exibir a descrição e as informações da tabela.

5. Se quiser, acesse a guia Esquema para ver a definição do esquema da tabela.

bq

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

   Activate Cloud Shell

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

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

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

Java

Antes de 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

public class GetTable {

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

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

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

Node.js

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

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

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

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

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

PHP

Antes de 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 em PHP.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

from google.cloud import bigquery

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

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

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

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

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 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: BASE TABLE: uma tabela padrão CLONE: um clone da tabela SNAPSHOT: um snapshot de tabela VIEW: uma visualização MATERIALIZED VIEW: uma visualização materializada ou uma réplica de visualização materializada EXTERNAL: uma tabela que se refere a uma fonte de dados externa
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
base_table_catalog	STRING	Para clones de tabelas e snapshots de tabelas, é o projeto da tabela base. Aplicável apenas a tabelas com table_type definido como CLONE ou SNAPSHOT.
base_table_schema	STRING	Para clones de tabelas e snapshots de tabelas, é o conjunto de dados da tabela base. Aplicável apenas a tabelas com table_type definido como CLONE ou SNAPSHOT.
base_table_name	STRING	Para clones de tabelas e snapshots de tabelas, o nome da tabela base. Aplicável apenas a tabelas com table_type definido como CLONE ou SNAPSHOT.
snapshot_time_ms	TIMESTAMP	Para clones de tabelas e snapshots de tabelas, a hora em que a operação do clone ou do snapshot foi executada na tabela base para criar essa tabela. Se a viagem no tempo foi usada, esse campo vai conter o carimbo de data/hora da viagem. Caso contrário, o campo snapshot_time_ms será igual ao campo creation_time. Aplicável apenas a tabelas com table_type definido como CLONE ou SNAPSHOT.
replica_source_catalog	STRING	Para réplicas de visualização materializadas, o projeto da visualização materializada base.
replica_source_schema	STRING	Para réplicas de visualização materializadas, o conjunto de dados da visualização materializada base.
replica_source_name	STRING	Para réplicas de visualização materializada, o nome da visualização materializada base.
replication_status	STRING	Para réplicas de visualização materializadas, o status da replicação da visualização materializada base para a réplica de visualização materializada. uma das seguintes opções: REPLICATION_STATUS_UNSPECIFIED ACTIVE: a replicação está ativa sem erros SOURCE_DELETED: a visualização materializada de origem foi excluída. PERMISSION_DENIED: a visualização materializada da origem não foi autorizada no conjunto de dados que contém as tabelas de origem do BigLake do Amazon S3 usadas na consulta que criou a visualização materializada. UNSUPPORTED_CONFIGURATION: há um problema com os pré-requisitos da réplica, exceto a autorização de visualização materializada da origem.
replication_error	STRING	Se replication_status indicar um problema de replicação para uma réplica de visualização materializada, o replication_error fornecerá mais detalhes sobre o problema.
ddl	STRING	A instrução DDL que pode ser usada para recriar a tabela, como CREATE TABLE ou CREATE VIEW
default_collation_name	STRING	Nome da especificação de compilação padrão, se houver. Caso contrário, NULL.
upsert_stream_apply_watermark	TIMESTAMP	Para tabelas que usam captura de dados alterados (CDC), a hora em que as modificações de linha foram aplicadas pela última vez. Para mais informações, consulte Monitorar o progresso da operação de inserção de tabelas.

Exemplos

Exemplo 1:

O exemplo a seguir recupera metadados de tabela para todas as tabelas no conjunto de dados chamado mydataset. Os metadados retornados são para todos os tipos de 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 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.

Observação: nomes de visualizações do INFORMATION_SCHEMA diferenciam maiúsculas e minúsculas.

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

O resultado será semelhante ao seguinte. Para facilitar a leitura, algumas colunas são excluídas do resultado.

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

Exemplo 2:

O exemplo a seguir recupera metadados de todas as tabelas do tipo CLONE ou SNAPSHOT da visualização INFORMATION_SCHEMA.TABLES. 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.

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

O resultado será semelhante ao seguinte. Para facilitar a leitura, algumas colunas são excluídas do resultado.

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

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.

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

O resultado será semelhante ao seguinte:

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       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
description	STRING	Uma descrição da tabela
enable_refresh	BOOL	Se a atualização automática está ativada para uma visualização materializada.
expiration_timestamp	TIMESTAMP	A hora em que esta tabela expira
friendly_name	STRING	O nome descritivo da tabela.
kms_key_name	STRING	O nome da chave do Cloud KMS usada para criptografar a tabela
labels	ARRAY<STRUCT<STRING, STRING>>	Uma matriz de STRUCTs que representam as identificações na tabela
partition_expiration_days	FLOAT64	A vida útil padrão, em dias, de todas as partições em uma tabela particionada
refresh_interval_minutes	FLOAT64	Com que frequência uma visualização materializada é atualizada
require_partition_filter	BOOL	Se as consultas na tabela exigem um filtro de partição
tags	ARRAY<STRUCT<STRING, STRING>>	Tags anexadas a uma tabela em uma sintaxe <key, value> com namespace. Para mais informações, consulte Tags e acesso condicional.

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.
bigtable_options	STRING Obrigatório apenas ao criar uma tabela externa do Bigtable. Especifica o esquema da tabela externa do Bigtable no formato JSON. Para conferir uma lista de opções de definição de tabela do Bigtable, consulte BigtableOptions na Referência da API REST.
column_name_character_map	STRING Define o escopo dos caracteres de nome de coluna compatíveis e o comportamento de processamento desses caracteres. A configuração padrão é STRICT, o que significa que os caracteres sem suporte causam erros no BigQuery. V1 e V2 substituem os caracteres não aceitos por sublinhados. Os valores aceitos são: STRICT. Ativa nomes de colunas flexíveis. Esse é o valor padrão. Os jobs de carregamento com caracteres incompatíveis nos nomes de colunas apresentam falha com uma mensagem de erro. Para configurar a substituição de caracteres sem suporte por sublinhados para que o job de carregamento seja bem-sucedido, especifique a configuração default_column_name_character_map. V1 Os nomes das colunas podem conter apenas caracteres padrão de nome de coluna. Os caracteres não aceitos são substituídos por sublinhados. Esse é o comportamento padrão para tabelas criadas antes da introdução de column_name_character_map. V2. Além dos caracteres padrão de nome de coluna, ele também oferece suporte a nomes de colunas flexíveis. Os caracteres não aceitos são substituídos por sublinhados. Aplica-se a dados CSV e Parquet.
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.
decimal_target_types	ARRAY<STRING> Determina como converter um tipo Decimal. Equivalente a ExternalDataConfiguration.decimal_target_types Exemplo: ["NUMERIC", "BIGNUMERIC"].
description	STRING Uma descrição da tabela.
enable_list_inference	BOOL Se true, use a inferência de esquema especificamente para o tipo lógico Parquet LIST. Aplicável a dados Parquet.
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.
enum_as_string	BOOL Se true, inferir o tipo lógico Parquet ENUM como STRING em vez de BYTES por padrão. Aplicável a dados Parquet.
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 compatíveis para CREATE EXTERNAL TABLE incluem: AVRO, CLOUD_BIGTABLE, CSV, DATASTORE_BACKUP, DELTA_LAKE (pré-lançamento), GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (ou JSON), ORC, PARQUET. Os valores compatíveis para LOAD DATA incluem: AVRO, CSV, DELTA_LAKE (pré-lançamento ), NEWLINE_DELIMITED_JSON (ou JSON)ORC, PARQUET. O valor JSON é equivalente a NEWLINE_DELIMITED_JSON.
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".
file_set_spec_type	STRING Especifica como interpretar URIs de origem para jobs de carregamento e tabelas externas. Os valores aceitos são: FILE_SYSTEM_MATCH. Expande URIs de origem listando arquivos do armazenamento de objetos. Esse é o comportamento padrão se FileSetSpecType não estiver definido. NEW_LINE_DELIMITED_MANIFEST. Indica que os URIs fornecidos são arquivos de manifesto delimitados por nova linha, com um URI por linha. Os arquivos de manifesto não aceitam URIs com caracteres curinga, e todos os arquivos de dados referenciados precisam estar no mesmo bucket que o arquivo de manifesto. Por exemplo, se você tiver um URI de origem de "gs://bucket/path/file" e file_set_spec_type for FILE_SYSTEM_MATCH, o arquivo será usado diretamente como um arquivo de dados. Se file_set_spec_type for NEW_LINE_DELIMITED_MANIFEST, cada linha no arquivo será interpretada como um URI que aponta para um arquivo de dados.
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.
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.
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 Google.
max_staleness	INTERVAL Aplicável a tabelas do BigLake e tabelas de objetos. Especifica se os metadados em cache são usados pelas operações na tabela e quando eles precisam ser atualizados para que a operação possa usá-los. Para desativar o armazenamento em cache de metadados, especifique 0. Esse é o padrão. Para ativar o armazenamento em cache de metadados, especifique um valor de literal de intervalo entre 30 minutos e 7 dias. Por exemplo, especifique INTERVAL 4 HOUR para um intervalo de inatividade de 4 horas. Com esse valor, as operações na tabela usarão metadados em cache se tiverem sido atualizados nas últimas 4 horas. Se os metadados armazenados em cache forem mais antigos que isso, a operação retornará aos metadados do Cloud Storage.
null_marker	STRING A string que representa os valores NULL em um arquivo CSV. Aplica-se a dados CSV.
object_metadata	STRING Obrigatório apenas ao criar uma tabela de objetos. Defina o valor dessa opção como SIMPLE ao criar uma tabela de objetos.
preserve_ascii_control_characters	BOOL Se true, os caracteres ASCII de controle incorporados que são os primeiros 32 caracteres na tabela ASCII, que variam de "\x00" a "\x1F", serão preservados. 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.
reference_file_schema_uri	STRING Arquivo de referência fornecido pelo usuário com o esquema da tabela. Aplicável aos dados Parquet/ORC/AVRO. Exemplo: "gs://bucket/path/reference_schema_file.parquet".
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 Google a ser consultada. Aplicável aos dados do Planilhas Google. 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 Google.
uris	Para tabelas externas, incluindo de objetos, que não sejam do Bigtable: ARRAY<STRING> Uma matriz de URIs totalmente qualificados para os locais de dados externos. Cada URI pode conter um caractere curinga de asterisco (*), que precisa vir depois do nome do bucket. Quando você especifica valores uris voltados para vários arquivos, todos eles precisam compartilhar um esquema compatível. Os exemplos a seguir mostram valores uris válidos: ['gs://bucket/path1/myfile.csv'] ['gs://bucket/path1/*.csv'] ['gs://bucket/path1/*', 'gs://bucket/path2/file00*'] Para tabelas do Bigtable: STRING O URI que identifica a tabela do Bigtable a ser usada como fonte de dados. Só é possível especificar um URI do Bigtable. Exemplo: https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name Para mais informações sobre como criar um URI do Bigtable, consulte Como recuperar o URI do Bigtable.

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

Observação: nomes de visualizações do INFORMATION_SCHEMA diferenciam maiúsculas e minúsculas.

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

O resultado será semelhante ao seguinte:

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

Observação: tabelas sem prazo de validade são excluídas dos resultados da consulta.

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

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

O resultado será semelhante ao seguinte:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | 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 do GoogleSQL 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.
COLUMN_DEFAULT	STRING	O valor padrão da coluna, se houver; Caso contrário, o valor será NULL
ROUNDING_MODE	STRING	O modo de arredondamento usado para valores gravados no campo se o tipo dele for um NUMERIC ou BIGNUMERIC parametrizado. Caso contrário, o valor será NULL.

Exemplos

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

Observação: os nomes da visualização INFORMATION_SCHEMA diferenciam maiúsculas e minúsculas.

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

O resultado será semelhante ao seguinte. Para facilitar a leitura, algumas colunas são excluídas do resultado.

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

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 do GoogleSQL coluna
DESCRIPTION	STRING	A descrição da coluna
COLLATION_NAME	STRING	Nome da especificação da ordenaçã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 ordenação será retornada, se existir. Caso contrário, NULL é retornado.
ROUNDING_MODE	STRING	O modo de arredondamento usado ao aplicar a precisão e a escala aos valores NUMERIC ou BIGNUMERIC parametrizados. Caso contrário, o valor é NULL.

Exemplos

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

Para ver os metadados sobre as colunas author e difference, execute a consulta a seguir.

Observação: nomes de visualizações do INFORMATION_SCHEMA diferenciam maiúsculas e minúsculas.

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

O resultado será semelhante ao seguinte. Para facilitar a leitura, algumas colunas são excluídas do resultado.

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

Visualização TABLE_STORAGE

Visualização

Este produto ou recurso está sujeito aos "Termos das ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos do serviço. Os produtos e recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

As visualizações TABLE_STORAGE e TABLE_STORAGE_BY_ORGANIZATION têm este esquema:

Nome da coluna	Tipo de dados	Valor
PROJECT_ID	STRING	O ID do projeto que contém o conjunto de dados.
PROJECT_NUMBER	INT64	O número do projeto que contém o conjunto de dados.
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 a visualização materializada, também conhecido como datasetId
TABLE_NAME	STRING	O nome da tabela ou visualização materializada, também conhecido como tableId.
CREATION_TIME	TIMESTAMP	A hora 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 (não compactados) lógicos na tabela ou visualização materializada.
ACTIVE_LOGICAL_BYTES	INT64	Número de bytes lógicos (não compactados) com menos de 90 dias.
LONG_TERM_LOGICAL_BYTES	INT64	Número de bytes lógicos (não compactados) com mais de 90 dias.
CURRENT_PHYSICAL_BYTES	INT64	Número total de bytes físicos para o armazenamento atual da tabela em todas as partições.
TOTAL_PHYSICAL_BYTES	INT64	Número total de bytes físicos (compactados) usados para armazenamento, incluindo bytes ativos, de longo prazo e de viagem no tempo (dados excluídos ou alterados) Segurança contra falhas (dados excluídos ou alterados retidos após a viagem no tempo window) bytes não são incluídos.
ACTIVE_PHYSICAL_BYTES	INT64	Número de bytes físicos (compactados) com menos de 90 dias, incluindo bytes de viagem no tempo (dados excluídos ou alterados).
LONG_TERM_PHYSICAL_BYTES	INT64	Número de bytes físicos (compactados) com mais de 90 dias.
TIME_TRAVEL_PHYSICAL_BYTES	INT64	Número de bytes (não compactados) físicos usados pelo armazenamento de viagem no tempo (dados excluídos ou alterados)
STORAGE_LAST_MODIFIED_TIME	TIMESTAMP	O horário mais recente em que os dados foram gravados na tabela.
DELETED	BOOLEAN	Indica se a tabela foi excluída.
TABLE_TYPE	STRING	O tipo de tabela. Por exemplo, EXTERNAL ou BASE TABLE.
FAIL_SAFE_PHYSICAL_BYTES	INT64	Número de bytes físicos (compactados) usados pelo armazenamento seguro contra falhas (dados excluídos ou alterados).
LAST_METADATA_INDEX_REFRESH_TIME	TIMESTAMP	O horário da última atualização do índice de metadados da tabela.

Exemplos

Exemplo 1:

O exemplo a seguir mostra o total de bytes lógicos faturados pelo projeto atual.

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

O resultado será semelhante ao seguinte:

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

Exemplo 2:

O exemplo a seguir mostra como prever a diferença de preço por conjunto de dados entre modelos de faturamento lógico e físico nos próximos 30 dias. Neste exemplo, pressupomos que o uso futuro do armazenamento seja constante nos próximos 30 dias a partir do momento em que a consulta foi executada. A previsão é limitada a tabelas de base e exclui todos os outros tipos de tabelas dentro de um conjunto de dados.

Os preços usados nas variáveis de preço desta consulta são para a região us-central1. Se você quiser executar essa consulta para uma região diferente, atualize as variáveis de preço adequadamente. Consulte Preços de armazenamento para ver informações sobre preços.

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

   Acesse a página do BigQuery

2. Insira a seguinte consulta do GoogleSQL na caixa Editor de consultas. INFORMATION_SCHEMA requer sintaxe do GoogleSQL. O GoogleSQL é a sintaxe padrão no Console do Google Cloud.

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

   Observação: os nomes da visualização INFORMATION_SCHEMA diferenciam maiúsculas e minúsculas.

3. Clique em Executar.

O resultado é semelhante a este:

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

Listar tabelas em um conjunto de dados

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

• Usando o Console do Google Cloud.
• usando o comando bq ls da ferramenta de linha de comando bq;
• chamando o 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 Google Cloud, no painel de navegação, clique no seu 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

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

   Activate Cloud Shell

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

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

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

Go

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

Java

Antes de 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

public class ListTables {

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

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

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

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

Node.js

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

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

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

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

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

PHP

Antes de 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 em PHP.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

from google.cloud import bigquery

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

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

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

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

Ruby

Antes de testar esta amostra, siga as instruções de configuração do 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 em Ruby.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

require "google/cloud/bigquery"

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

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

Segurança de tabelas

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

A seguir

• Para mais informações sobre conjuntos de dados, consulte Introdução aos conjuntos de dados.
• Para mais informações sobre o gerenciamento de dados da tabela, consulte Como gerenciar dados da tabela.
• Para mais informações sobre como especificar esquemas de tabela, consulte Como especificar um esquema.
• Para mais informações sobre como modificar esquemas de tabelas, consulte esta página.
• Para mais informações sobre como gerenciar tabelas, consulte Como gerenciar tabelas.
• Acesse Introdução ao BigQuery INFORMATION_SCHEMA para uma visão geral de INFORMATION_SCHEMA.

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