Crie e use tabelas

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

Depois de criar uma tabela, pode fazer o seguinte:

  • Controlar o acesso aos dados da tabela.
  • Obtenha informações sobre as suas tabelas.
  • Apresenta as tabelas num conjunto de dados.
  • Obter metadados de tabelas.

Para mais informações sobre a gestão de tabelas, incluindo a atualização das propriedades das tabelas, a cópia de uma tabela e a eliminação de uma tabela, consulte o artigo Gerir tabelas.

Antes de começar

Conceda funções de gestão de identidades e acessos (IAM) que dão aos utilizadores as autorizações necessárias para realizar cada tarefa neste documento.

Funções necessárias

Para receber as autorizações de que precisa para criar uma tabela, peça ao seu administrador que lhe conceda as seguintes funções do IAM:

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Estas funções predefinidas contêm as autorizações necessárias para criar uma tabela. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

São necessárias as seguintes autorizações para criar uma tabela:

  • bigquery.tables.create no conjunto de dados onde está a criar a tabela.
  • bigquery.tables.getData em todas as tabelas e vistas a que a sua consulta faz referência se estiver a guardar os resultados da consulta como uma tabela.
  • bigquery.jobs.create no projeto, se estiver a criar a tabela carregando dados ou guardando resultados de consultas numa tabela.
  • bigquery.tables.updateData na tabela se estiver a anexar ou substituir uma tabela com resultados da consulta.

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Nomenclatura das tabelas

Quando cria uma tabela no BigQuery, o nome da tabela tem de ser único por conjunto de dados. O nome da tabela pode:

  • Conter carateres com um total de até 1024 bytes UTF-8.
  • Conter carateres Unicode nas categorias L (letra), M (marca), N (número), Pc (conetor, incluindo sublinhado), Pd (travessão) e Zs (espaço). Para mais informações, consulte Categoria geral.

Seguem-se exemplos de nomes de tabelas válidos: table 01, ग्राहक, 00_お客様, étudiant-01.

Advertências:

  • Os nomes das tabelas são sensíveis a maiúsculas e minúsculas por predefinição. mytable e MyTable podem coexistir no mesmo conjunto de dados, a menos que façam parte de um conjunto de dados com a opção de distinção entre maiúsculas e minúsculas desativada.
  • Alguns nomes de tabelas e prefixos de nomes de tabelas são reservados. Se receber um erro a indicar que o nome ou o prefixo da tabela está reservado, selecione um nome diferente e tente novamente.

  • Se incluir vários operadores de ponto (.) numa sequência, os operadores duplicados são removidos implicitamente.

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

    Torna-se: project_name.dataset_name.table_name

Crie tabelas

Pode criar uma tabela no BigQuery das seguintes formas:

  • Manualmente através do comando Google Cloud console ou da ferramenta de linhas de comando bq bq mk.
  • De forma programática, chamando o método da API tables.insert.
  • Usando as bibliotecas cliente.
  • A partir dos resultados da consulta.
  • Ao definir uma tabela que faz referência a uma origem de dados externa.
  • Quando carrega dados.
  • Através de uma declaração de linguagem de definição de dados (LDD) CREATE TABLE.

Crie uma tabela vazia com uma definição de esquema

Pode criar uma tabela vazia com uma definição de esquema das seguintes formas:

  • Introduza o esquema através da Google Cloud consola.
  • Forneça o esquema inline através da ferramenta de linhas de comando bq.
  • Envie um ficheiro de esquema JSON através da ferramenta de linhas de comando bq.
  • Forneça o esquema num recurso de tabela quando chamar o método tables.insert das APIs.

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

Depois de criar a tabela, pode carregar dados para a mesma ou preenchê-la escrevendo os resultados da consulta na mesma.

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

Consola

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No painel Explorador, expanda o seu projeto e, de seguida, selecione um conjunto de dados.
  3. Na secção Informações do conjunto de dados, clique em Criar tabela.
  4. No painel Criar tabela, especifique os seguintes detalhes:
    1. Na secção Origem, selecione Tabela vazia na lista Criar tabela a partir de.
    2. Na secção Destino, especifique os seguintes detalhes:
      1. Para Conjunto de dados, selecione o conjunto de dados no qual quer criar a tabela.
      2. No campo Tabela, introduza o nome da tabela que quer criar.
      3. Verifique se o campo Tipo de tabela está definido como Tabela nativa.
    3. Na secção Esquema, introduza a definição do esquema. Pode introduzir manualmente informações do esquema através de um dos seguintes métodos:
      • Opção 1: clique em Editar como texto e cole o esquema sob a forma de uma matriz JSON. Quando usa uma matriz JSON, gera o esquema através do mesmo processo que criar um ficheiro de esquema JSON. Pode ver o esquema de uma tabela existente no formato JSON introduzindo o seguinte comando: 
            bq show --format=prettyjson dataset.table
      • Opção 2: clique em Adicionar campo e introduza o esquema da tabela. Especifique o Nome, Tipo e Modo de cada campo.
    4. Opcional: especifique as definições de partição e cluster. Para mais informações, consulte os artigos Criar tabelas particionadas e Criar e usar tabelas agrupadas.
    5. Opcional: na secção Opções avançadas, se quiser usar uma chave de encriptação gerida pelo cliente, selecione a opção Usar uma chave de encriptação gerida pelo cliente (CMEK). Por predefinição, o BigQuery encripta o conteúdo do cliente armazenado em repouso através de um Google-owned and Google-managed encryption key.
    6. Clique em Criar tabela.

SQL

O exemplo seguinte cria uma tabela denominada newtable que expira a 1 de janeiro de 2023:

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, introduza a seguinte declaraçã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, consulte o artigo Execute 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. Use o comando bq mk com a flag --table ou -t. Pode fornecer informações do esquema de tabela incorporadas ou com um ficheiro de esquema JSON. Para ver 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 seguintes links para mais informações sobre estes parâmetros opcionais:

    Se estiver a criar uma tabela num projeto que não seja o projeto predefinido, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

    Para criar uma tabela vazia num conjunto de dados existente com uma definição de esquema, introduza 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 o seguinte:

    • integer é o tempo de vida predefinido (em segundos) para a tabela. O valor mínimo é de 3600 segundos (uma hora). O tempo de expiração é avaliado como a hora UTC atual mais o valor inteiro. Se definir a hora de expiração quando cria uma tabela, a definição de expiração da tabela predefinida 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 chave-valor que especificam etiquetas.
    • key_3:value_3 são pares chave-valor que especificam etiquetas. Adicione várias etiquetas com a mesma flag, separando os pares chave:valor por vírgulas.
    • project_id é o ID do seu projeto.
    • dataset é um conjunto de dados no seu projeto.
    • table é o nome da tabela que está a criar.
    • schema é uma definição de esquema inline no formato field:data_type,field:data_type ou o caminho para o ficheiro de esquema JSON no seu computador local.

    Quando especifica o esquema na linha de comandos, não pode incluir um tipo RECORD (STRUCT), não pode incluir uma descrição da coluna e não pode especificar o modo da coluna. Todos os modos têm NULLABLE como predefinição. Para incluir descrições, modos e tipos RECORD, forneça um ficheiro de esquema JSON em alternativa.

    Exemplos:

    Introduza o seguinte comando para criar uma tabela com uma definição de esquema inline. Este comando cria uma tabela com o nome mytable em mydataset no seu projeto predefinido. A expiração da tabela está definida para 3600 segundos (1 hora), a descrição está definida como This is my table e a etiqueta está definida como organization:development. O comando usa o atalho -t em vez de --table. O esquema é especificado inline 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

    Introduza o seguinte comando para criar uma tabela através de um ficheiro de esquema JSON. Este comando cria uma tabela denominada mytable em mydataset no seu projeto predefinido. A validade da tabela está definida como 3600 segundos (1 hora), a descrição está definida como This is my table e a etiqueta está definida como organization:development. O caminho para o ficheiro de esquema é /tmp/myschema.json.

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

    Introduza o seguinte comando para criar uma tabela com um ficheiro de esquema JSON. Este comando cria uma tabela com o nome mytable em mydataset em myotherproject. A validade da tabela está definida como 3600 segundos (1 hora), a descrição está definida como This is my table e a etiqueta está definida como organization:development. O caminho para o ficheiro de esquema é /tmp/myschema.json.

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

    Depois de criar a tabela, pode atualizar a respetiva data de validade, descrição e etiquetas. Também pode modificar a definição do esquema.

    3. Terraform

    Use o recurso google_bigquery_table.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

    Crie uma tabela

    O exemplo seguinte cria 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

}

    Crie uma tabela e conceda acesso à mesma

    O exemplo seguinte cria uma tabela denominada mytable e, em seguida, usa o recurso google_bigquery_table_iam_policy para conceder-lhe acesso. Execute este passo apenas se quiser conceder acesso à tabela a responsáveis que não têm acesso ao conjunto de dados no qual 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:raha@altostrat.com",
    ]
  }
}

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

    Crie uma tabela com uma chave de encriptação gerida pelo cliente

    O exemplo seguinte cria uma tabela denominada 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. Tem de 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 num Google Cloud projeto, conclua os passos nas secções seguintes.

    Prepare o Cloud Shell

    1. Inicie o Cloud Shell.

    2. Defina o Google Cloud projeto predefinido onde quer aplicar as suas configurações do Terraform.

      Só tem de executar este comando uma vez por projeto e pode executá-lo em qualquer diretório.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      As variáveis de ambiente são substituídas se definir valores explícitos no ficheiro de configuração do Terraform.

    Prepare o diretório

    Cada ficheiro de configuração do Terraform tem de ter o seu próprio diretório (também denominado módulo raiz).

    1. No Cloud Shell, crie um diretório e um novo ficheiro nesse diretório. O nome do ficheiro tem de ter a extensão .tf, por exemplo, main.tf. Neste tutorial, o ficheiro é denominado main.tf. 
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

    2. Se estiver a seguir um tutorial, pode copiar o código de exemplo em cada secção ou passo.

      Copie o exemplo de código para o ficheiro main.tf criado recentemente.

      Opcionalmente, copie o código do GitHub. Isto é recomendado quando o fragmento do Terraform faz parte de uma solução completa.

    3. Reveja e modifique os parâmetros de exemplo para aplicar ao seu ambiente.
    4. Guarde as alterações.
    5. Inicialize o Terraform. Só tem de fazer isto uma vez por diretório. 
      terraform init

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

      terraform init -upgrade

    Aplique as alterações

    1. Reveja a configuração e verifique se os recursos que o Terraform vai criar ou atualizar correspondem às suas expetativas: 
      terraform plan

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

    2. Aplique a configuração do Terraform executando o seguinte comando e introduzindo yes no comando: 
      terraform apply

      Aguarde até que o Terraform apresente a mensagem "Apply complete!" (Aplicação concluída!).

    3. Abra o seu Google Cloud projeto para ver os resultados. Na Google Cloud consola, navegue para os seus recursos na IU para se certificar de que o Terraform os criou ou atualizou.

    API

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

    C#

    Antes de experimentar este exemplo, siga as C#instruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API C# BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as PHPinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API PHP BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Rubyinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Ruby BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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

Crie uma tabela vazia sem uma definição de esquema

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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());
    }
  }
}

Crie uma tabela a partir do resultado de uma consulta

Para criar uma tabela a partir do resultado de uma consulta, escreva os resultados numa tabela de destino.

Consola

  1. Abra a página do BigQuery na Google Cloud consola.

    Aceda à página do BigQuery

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

  3. Introduza uma consulta SQL válida.

  4. Clique em Mais e, de seguida, selecione Definições de consulta.

    Definições da consulta

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

    Defina o destino

  6. Na secção Destino, selecione o Conjunto de dados no qual quer criar a tabela e, de seguida, escolha um ID da tabela.

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

    • Escrever se estiver vazia: escreve os resultados da consulta na tabela apenas se esta estiver vazia.
    • Anexar à tabela: anexa os resultados da consulta a uma tabela existente.
    • Substituir tabela: substitui uma tabela existente com o mesmo nome usando os resultados da consulta.

  8. Opcional: para Localização de dados, escolha a sua localização.

  9. Para atualizar as definições de consulta, clique em Guardar.

  10. Clique em Executar. Esta ação cria uma tarefa de consulta que escreve os resultados da consulta na tabela especificada.

Em alternativa, se se esquecer de especificar uma tabela de destino antes de executar a consulta, pode copiar a tabela de resultados em cache para uma tabela permanente clicando no botão Guardar resultados acima do editor.

SQL

O exemplo seguinte usa a declaração CREATE TABLE para criar a tabela trips a partir dos dados na tabela pública bikeshare_trips:

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, introduza a seguinte declaraçã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, consulte o artigo Execute uma consulta interativa.

Para mais informações, consulte o artigo Criar uma nova tabela a partir de uma tabela 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. Introduza o comando bq query e especifique a flag --destination_table para criar uma tabela permanente com base nos resultados da consulta. Especifique a flag use_legacy_sql=false para usar a sintaxe GoogleSQL. Para escrever os resultados da consulta numa tabela que não esteja no seu projeto predefinido, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato:project_id:dataset.

    Opcional: forneça o sinalizador --location e defina o valor para a sua localização.

    Para controlar a disposição de escrita de uma tabela de destino existente, especifique um dos seguintes flags opcionais:

    • --append_table: se a tabela de destino existir, os resultados da consulta são anexados à mesma.

    • --replace: se a tabela de destino existir, é substituída pelos resultados da consulta.

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

      Substitua o seguinte:

    • location é o nome da localização usada para processar a consulta. A flag --location é opcional. Por exemplo, se estiver a usar o BigQuery na região de Tóquio, pode definir o valor da flag como asia-northeast1. Pode predefinir um valor para a localização através do ficheiro .bigqueryrc.

    • project_id é o ID do seu projeto.

    • dataset é o nome do conjunto de dados que contém a tabela na qual está a escrever os resultados da consulta.

    • table é o nome da tabela na qual está a escrever os resultados da consulta.

    • query é uma consulta na sintaxe do GoogleSQL.

      Se não for especificada nenhuma flag de disposição de escrita, o comportamento predefinido é escrever os resultados na tabela apenas se estiver vazia. Se a tabela existir e não estiver vazia, é devolvido o seguinte erro: BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1: Already Exists: Table project_id:dataset.table.

      Exemplos:

      Introduza o seguinte comando para escrever os resultados da consulta numa tabela de destino denominada mytable em mydataset. O conjunto de dados está no seu projeto predefinido. Uma vez que não é especificada nenhuma flag de disposição de escrita no comando, a tabela tem de ser nova ou estar vazia. Caso contrário, é devolvido um erro Already exists. A consulta extrai dados do conjunto de dados público de nomes dos EUA.

      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'

      Introduza o seguinte comando para usar os resultados da consulta para substituir uma tabela de destino denominada mytable em mydataset. O conjunto de dados está no seu projeto predefinido. O comando usa a flag --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'

      Introduza o seguinte comando para anexar os resultados da consulta a uma tabela de destino denominada mytable em mydataset. O conjunto de dados está em my-other-project e não no seu projeto predefinido. O comando usa a flag --append_table para anexar os resultados da consulta à 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'

      O resultado de cada um destes exemplos tem o seguinte aspeto. Para facilitar a leitura, alguns resultados são truncados.

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

API

Para guardar os resultados da consulta numa tabela permanente, chame o método jobs.insert, configure uma tarefa query e inclua um valor para a propriedade destinationTable. Para controlar a disposição de gravação de uma tabela de destino existente, configure a propriedade writeDisposition.

Para controlar a localização do processamento da tarefa de consulta, especifique a propriedade location na secção jobReference do recurso de tarefa.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Para guardar os resultados da consulta numa tabela permanente, defina a tabela de destino para o TableId desejado num 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Para guardar os resultados da consulta numa tabela permanente, crie um QueryJobConfig e defina o destino para o TableReference desejado. Transmita a configuração da tarefa ao método query. 
from google.cloud import bigquery

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

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

job_config = bigquery.QueryJobConfig(destination=table_id)

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

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

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

Crie uma tabela que faça referência a uma origem de dados externa

Uma origem de dados externa é aquela que pode consultar diretamente a partir do BigQuery, mesmo que os dados não estejam no armazenamento do BigQuery. Por exemplo, pode ter dados numa base de dados Google Cloud diferente, em ficheiros no Cloud Storage ou num produto da nuvem diferente que gostaria de analisar no BigQuery, mas que não está a postos para migrar.

Para mais informações, consulte o artigo Introdução a origens de dados externas.

Crie uma tabela quando carregar dados

Quando carrega dados para o BigQuery, pode carregá-los para uma nova tabela ou partição, anexá-los a uma tabela ou partição existente, ou substituir uma tabela ou partição. Não tem de criar uma tabela vazia antes de carregar dados para a mesma. Pode criar a nova tabela e carregar os dados ao mesmo tempo.

Quando carrega dados para o BigQuery, pode fornecer o esquema da tabela ou da partição ou, para formatos de dados suportados, pode usar a deteção automática do esquema.

Para mais informações sobre o carregamento de dados, consulte o artigo Introdução ao carregamento de dados no BigQuery.

Controle o acesso às tabelas

Para configurar o acesso a tabelas e vistas, pode conceder uma função do IAM a uma entidade nos seguintes níveis, apresentados por ordem do intervalo de recursos permitidos (do maior para o menor):

  • um nível elevado na Google Cloud hierarquia de recursos, como o nível do projeto, da pasta ou da organização
  • ao nível do conjunto de dados
  • Ao nível da tabela ou da vista

Também pode restringir o acesso aos dados nas tabelas através dos seguintes métodos:

O acesso com qualquer recurso protegido pela IAM é cumulativo. Por exemplo, se uma entidade não tiver acesso ao nível superior, como um projeto, pode conceder-lhe acesso ao nível do conjunto de dados. Em seguida, a entidade tem acesso às tabelas e às visualizações de propriedade no conjunto de dados. Da mesma forma, se a entidade não tiver acesso ao nível superior ou ao nível do conjunto de dados, pode conceder-lhe acesso ao nível da tabela ou da visualização.

A concessão de funções da IAM a um nível superior na Google Cloud hierarquia de recursos , como o nível do projeto, da pasta ou da organização, dá à entidade acesso a um conjunto vasto de recursos. Por exemplo, conceder uma função a uma entidade ao nível do projeto dá a essa entidade autorizações que se aplicam a todos os conjuntos de dados ao longo do projeto.

A concessão de uma função ao nível do conjunto de dados especifica as operações que uma entidade tem permissão para realizar em tabelas e visualizações de propriedade nesse conjunto de dados específico, mesmo que a entidade não tenha acesso a um nível superior. Para ver informações sobre a configuração dos controlos de acesso ao nível do conjunto de dados, consulte o artigo Controlar o acesso aos conjuntos de dados.

A atribuição de uma função ao nível da tabela ou da visualização de propriedade especifica as operações que uma entidade tem autorização para realizar em tabelas e visualizações de propriedade específicas, mesmo que a entidade não tenha acesso a um nível superior. Para obter informações sobre a configuração de controlos de acesso ao nível da tabela, consulte o artigo Controlar o acesso a tabelas e vistas.

Também pode criar funções personalizadas do IAM. Se criar uma função personalizada, as autorizações que concede dependem das operações específicas que quer que a entidade possa realizar.

Não pode definir uma autorização "negar" em nenhum recurso protegido pelo IAM.

Para mais informações acerca das funções e autorizações, consulte o artigo Compreender as funções na documentação do IAM e as autorizações e funções do IAM do BigQuery.

Obtenha informações sobre tabelas

Pode obter informações ou metadados sobre tabelas das seguintes formas:

Autorizações necessárias

No mínimo, para obter informações sobre tabelas, tem de ter autorizações de bigquery.tables.get. As seguintes funções do IAM predefinidas incluem autorizações bigquery.tables.get:

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

Além disso, se um utilizador tiver autorizações bigquery.datasets.create, quando esse utilizador cria um conjunto de dados, recebe acesso bigquery.dataOwner ao mesmo. O acesso bigquery.dataOwner dá ao utilizador a capacidade de obter metadados da tabela.

Para mais informações sobre as funções e as autorizações do IAM no BigQuery, consulte o artigo Controlo de acesso.

Obtenha informações da tabela

Para obter informações sobre tabelas:

Consola

  1. No painel de navegação, na secção Recursos, expanda o seu projeto e, de seguida, selecione um conjunto de dados.

  2. Clique no nome do conjunto de dados para o expandir. As tabelas e as vistas no conjunto de dados são apresentadas.

  3. Clique no nome da tabela.

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

  5. Opcionalmente, mude para o separador 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 apresentar todas as informações da tabela. Use a flag --schema para apresentar apenas informações do esquema da tabela. A flag --format pode ser usada para controlar a saída.

    Se estiver a receber informações sobre uma tabela num projeto diferente do seu projeto predefinido, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

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

    Onde:

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

    Exemplos:

    Introduza o seguinte comando para apresentar todas as informações sobre mytable em mydataset. mydataset está no seu projeto predefinido.

    bq show --format=prettyjson mydataset.mytable

    Introduza o seguinte comando para apresentar todas as informações sobre mytable em mydataset. O recurso mydataset está em myotherproject e não no seu projeto predefinido.

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

    Introduza o seguinte comando para apresentar apenas informações do esquema sobre mytable em mydataset. mydataset está em myotherproject e não no seu projeto predefinido.

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

    3. API

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

    Go

    Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as PHPinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API PHP BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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))

Obtenha informações de tabelas com INFORMATION_SCHEMA

INFORMATION_SCHEMA é uma série de vistas que fornecem acesso a metadados sobre conjuntos de dados, rotinas, tabelas, vistas, tarefas, reservas e dados de streaming.

Pode consultar as seguintes vistas para obter informações sobre tabelas:

  • Use as vistas INFORMATION_SCHEMA.TABLES e INFORMATION_SCHEMA.TABLE_OPTIONS para obter metadados sobre tabelas e vistas num projeto.
  • Use as vistas INFORMATION_SCHEMA.COLUMNS e INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para obter metadados sobre as colunas (campos) numa tabela.
  • Use as vistas INFORMATION_SCHEMA.TABLE_STORAGE para obter metadados acerca da utilização de armazenamento atual e histórico por uma tabela.

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

TABLES visualização

Quando consulta a vista INFORMATION_SCHEMA.TABLES, os resultados da consulta contêm uma linha para cada tabela ou vista num conjunto de dados. Para informações detalhadas sobre as visualizações, consulte a INFORMATION_SCHEMA.VIEWSvisualização.

A vista 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 a vista. Também conhecido como datasetId.
table_name STRING O nome da tabela ou da vista. Também conhecido como tableId.
table_type STRING O tipo de tabela; uma das seguintes opções:
managed_table_type STRING Esta coluna está em pré-visualização. O tipo de tabela gerida; uma das seguintes opções:
is_insertable_into STRING YES ou NO, consoante a tabela suportar ou não instruções DML INSERT
is_fine_grained_mutations_enabled STRING YES ou NO, consoante as mutações DML detalhadas estejam ativadas na tabela
is_typed STRING O valor é sempre NO
is_change_history_enabled STRING YES ou NO, consoante o histórico de alterações estar ativado ou não
creation_time TIMESTAMP Hora de criação da tabela
base_table_catalog STRING Para clones de tabelas e capturas instantâneas 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 instantâneos de tabelas, o conjunto de dados da tabela de base. Aplicável apenas a tabelas com table_type definido como CLONE ou SNAPSHOT.
base_table_name STRING Para clones de tabelas e instantâneos 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 instantâneos de tabelas, a hora em que a operação de clonagem ou instantâneo foi executada na tabela base para criar esta tabela. Se tiver sido usado o time travel, este campo contém a indicação de tempo do time travel. Caso contrário, o campo snapshot_time_ms é 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 vistas materializadas, o projeto da vista materializada de base.
replica_source_schema STRING Para réplicas de visualização materializada, o conjunto de dados da visualização materializada base.
replica_source_name STRING Para réplicas de vistas materializadas, o nome da vista materializada base.
replication_status STRING Para réplicas de vistas materializadas, o estado da replicação da vista materializada base para a réplica de vista materializada; uma das seguintes opções:
  • REPLICATION_STATUS_UNSPECIFIED
  • ACTIVE: a replicação está ativa sem erros
  • SOURCE_DELETED: A vista materializada de origem foi eliminada
  • PERMISSION_DENIED: A vista materializada de origem não foi autorizada no conjunto de dados que contém as tabelas BigLake do Amazon S3 de origem usadas na consulta que criou a vista materializada.
  • UNSUPPORTED_CONFIGURATION: existe um problema com os pré-requisitos da réplica, exceto a autorização da vista materializada de origem.
replication_error STRING Se replication_status indicar um problema de replicação para uma réplica de vista materializada, replication_error fornece mais detalhes sobre o problema.
ddl STRING A declaração LDD que pode ser usada para recriar a tabela, como CREATE TABLE ou CREATE VIEW
default_collation_name STRING O nome da especificação de ordenação predefinida se existir; caso contrário, NULL.
upsert_stream_apply_watermark TIMESTAMP Para tabelas que usam a captura de dados de alterações (CDC), a hora em que as modificações das linhas foram aplicadas pela última vez. Para mais informações, consulte o artigo Monitorize o progresso da operação de inserção/atualização da tabela.

Exemplos

Exemplo 1:

O exemplo seguinte obtém os metadados da tabela para todas as tabelas no conjunto de dados denominado mydataset. Os metadados devolvidos são para todos os tipos de tabelas no mydataset no seu projeto predefinido.

mydataset contém as seguintes tabelas:

  • mytable1: uma tabela padrão do BigQuery
  • myview1: uma vista do BigQuery

Para executar a consulta num projeto que não seja o seu projeto predefinido, 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.

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

O resultado é 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 seguinte obtém metadados de tabelas para todas as tabelas do tipo CLONE ou SNAPSHOT a partir da vista INFORMATION_SCHEMA.TABLES. Os metadados devolvidos são para tabelas em mydataset no seu projeto predefinido.

Para executar a consulta num projeto que não seja o seu projeto predefinido, 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 é 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 seguinte obtém as colunas table_name e ddl da vista INFORMATION_SCHEMA.TABLES para a tabela population_by_zip_2010 no conjunto de dados census_bureau_usa. Este conjunto de dados faz parte do programa de conjuntos de dados públicos do BigQuery.

Uma vez que a tabela que está a consultar se encontra noutro 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 é 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", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

TABLE_OPTIONS visualização

Quando consulta a vista INFORMATION_SCHEMA.TABLE_OPTIONS, os resultados da consulta contêm uma linha para cada opção, para cada tabela ou vista num conjunto de dados. Para ver informações detalhadas sobre as visualizações, consulte a vista INFORMATION_SCHEMA.VIEWS.

A vista 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 a vista também conhecido como datasetId
TABLE_NAME STRING O nome da tabela ou da vista também é conhecido como tableId
OPTION_NAME STRING Um dos valores de nome na tabela de opções
OPTION_TYPE STRING Um dos valores do 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 vista 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 encriptar a tabela

labels

ARRAY<STRUCT<STRING, STRING>>

 Uma matriz de STRUCT que representa as etiquetas na tabela

max_staleness

INTERVAL

 A desatualização máxima da tabela configurada para inserções/atualizações de captura de dados de alterações (CDC) do BigQuery

partition_expiration_days

FLOAT64

 O tempo de vida predefinido, em dias, de todas as partições numa tabela particionada

refresh_interval_minutes

FLOAT64

 Com que frequência uma vista materializada é atualizada

require_partition_filter

BOOL

 Se as consultas na tabela requerem um filtro de partição

tags

ARRAY<STRUCT<STRING, STRING>>

 Etiquetas anexadas a uma tabela numa sintaxe <key, value> com espaço de nomes. Para mais informações, consulte o artigo Etiquetas e acesso condicional.

Para tabelas externas, são possíveis as seguintes opções:

Opções
allow_jagged_rows

BOOL

Se true, permita linhas com colunas opcionais finais em falta.

Aplica-se a dados CSV.
allow_quoted_newlines

BOOL

Se true, permita secções de dados entre aspas que contenham carateres de nova linha no ficheiro.

Aplica-se a dados CSV.
bigtable_options

STRING

Só é necessário quando cria uma tabela externa do Bigtable.

Especifica o esquema da tabela externa do Bigtable no formato JSON.

Para ver uma lista de opções de definição de tabelas do Bigtable, consulte BigtableOptions na referência da API REST.
column_name_character_map

STRING

Define o âmbito dos carateres de nomes de colunas suportados e o comportamento de processamento de carateres não suportados. A predefinição é STRICT, o que significa que os carateres não suportados fazem com que o BigQuery apresente erros. V1 e V2 substituem todos os carateres não suportados por sublinhados.

Os valores suportados incluem:
compression

STRING

O tipo de compressão da origem de dados. Os valores suportados incluem: GZIP. Se não for especificado, a origem de dados não é comprimida.

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 desta tabela.
enable_list_inference

BOOL

Se true, use a inferência de esquemas especificamente para o tipo lógico LIST do Parquet.

Aplica-se a dados Parquet.
enable_logical_types

BOOL

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

Aplica-se a dados Avro.
encoding

STRING

A codificação de carateres dos dados. Os valores suportados incluem: UTF8 (ou UTF-8), ISO_8859_1 (ou ISO-8859-1), UTF-16BE, UTF-16LE, UTF-32BE ou UTF-32LE. O valor predefinido é UTF-8.

Aplica-se a dados CSV.
enum_as_string

BOOL

Se true, infira o tipo lógico ENUM Parquet como STRING em vez de BYTES por predefinição.

Aplica-se a dados Parquet.
expiration_timestamp

TIMESTAMP

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

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

STRING

O separador dos campos num ficheiro CSV.

Aplica-se a dados CSV.
format

STRING

O formato dos dados externos. Os valores suportados para CREATE EXTERNAL TABLE incluem: AVRO, CLOUD_BIGTABLE, CSV, DATASTORE_BACKUP, DELTA_LAKE (pré-visualização), GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (ou JSON), ORC e PARQUET.

Os valores suportados para LOAD DATA incluem: AVRO, CSV, DELTA_LAKE (pré-visualização) 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 por Hive.

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

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

STRING

Especifica como interpretar os URIs de origem para tarefas de carregamento e tabelas externas.

Os valores suportados incluem:

  • FILE_SYSTEM_MATCH. Expande os URIs de origem listando os ficheiros da loja de objetos. Este é o comportamento predefinido se FileSetSpecType não estiver definido.
  • NEW_LINE_DELIMITED_MANIFEST. Indica que os URIs fornecidos são ficheiros de manifesto delimitados por novas linhas, com um URI por linha. Os URIs com carateres universais não são suportados nos ficheiros de manifesto, e todos os ficheiros de dados referenciados têm de estar no mesmo contentor que o ficheiro de manifesto.

Por exemplo, se tiver um URI de origem de "gs://bucket/path/file" e o file_set_spec_type for FILE_SYSTEM_MATCH, o ficheiro é usado diretamente como um ficheiro de dados. Se o valor for NEW_LINE_DELIMITED_MANIFEST, cada linha no ficheiro é interpretada como um URI que aponta para um ficheiro de dados.file_set_spec_type
ignore_unknown_values

BOOL

Se true, ignore os valores adicionais que não estão representados no esquema da tabela, sem devolver um erro.

Aplica-se a dados CSV e JSON.
json_extension

STRING

Para dados JSON, indica um formato de intercâmbio JSON específico. Se não for especificado, o BigQuery lê os dados como registos JSON genéricos.

Os valores suportados incluem:
GEOJSON. Dados GeoJSON delimitados por Newline. Para mais informações, consulte Criar uma tabela externa a partir de um ficheiro GeoJSON delimitado por novas linhas.

max_bad_records

INT64

O número máximo de registos inválidos a ignorar ao ler os dados.

Aplica-se a: dados CSV, JSON e do Google Sheets.
max_staleness

INTERVAL

Aplicável a tabelas BigLake e tabelas de objetos.

Especifica se as operações na tabela usam metadados em cache e qual a antiguidade máxima dos metadados em cache para que a operação os use.

Para desativar a colocação em cache de metadados, especifique 0. Esta é a predefinição.

Para ativar o armazenamento em cache de metadados, especifique um valor literal de intervalo entre 30 minutos e 7 dias. Por exemplo, especifique INTERVAL 4 HOUR para um intervalo de desatualização de 4 horas. Com este valor, as operações na tabela usam metadados em cache se tiverem sido atualizados nas últimas 4 horas. Se os metadados em cache forem mais antigos, a operação recorre à obtenção de metadados do Cloud Storage.
null_marker

STRING

A string que representa os valores NULL num ficheiro CSV.

Aplica-se a dados CSV.
null_markers

ARRAY<STRING>

(Pré-visualizar)

A lista de strings que representam valores NULL num ficheiro CSV.

Não é possível usar esta opção com a opção null_marker.

Aplica-se a dados CSV.
object_metadata

STRING

Só é necessário quando cria uma tabela de objetos.

Defina o valor desta opção como SIMPLE quando criar uma tabela de objetos.
preserve_ascii_control_characters

BOOL

Se true, os carateres de controlo ASCII incorporados que são os primeiros 32 carateres na tabela ASCII, variando de "\x00" a "\x1F", são preservados.

Aplica-se a dados CSV.
projection_fields

STRING

Uma lista de propriedades de entidades a carregar.

Aplica-se aos dados do Datastore.
quote

STRING

A string usada para colocar entre aspas secções de dados num ficheiro CSV. Se os seus dados contiverem carateres 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

Ficheiro de referência facultado pelo utilizador com o esquema da tabela.

Aplica-se a dados Parquet/ORC/AVRO.

Exemplo: "gs://bucket/path/reference_schema_file.parquet".
require_hive_partition_filter

BOOL

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

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

STRING

Intervalo de uma folha de cálculo do Google Sheets a partir do qual fazer a consulta.

Aplica-se aos dados do Google Sheets.

Exemplo: "sheet1!A1:B20",
skip_leading_rows

INT64

O número de linhas na parte superior de um ficheiro a ignorar ao ler os dados.

Aplica-se a dados CSV e do Google Sheets.
source_column_match

STRING

(Pré-visualizar)

Isto controla a estratégia usada para fazer corresponder as colunas carregadas ao esquema.

Se este valor não for especificado, a predefinição baseia-se na forma como o esquema é fornecido. Se a deteção automática estiver ativada, o comportamento predefinido é fazer a correspondência das colunas por nome. Caso contrário, a predefinição é fazer a correspondência das colunas por posição. Isto é feito para manter o comportamento retrocompatível.

Os valores suportados incluem:

  • POSITION: correspondências por posição. Esta opção pressupõe que as colunas estão ordenadas da mesma forma que o esquema.
  • NAME: corresponde por nome. Esta opção lê a linha de cabeçalho como nomes de colunas e reordena as colunas para corresponder aos nomes dos campos no esquema. Os nomes das colunas são lidos a partir da última linha ignorada com base na propriedade skip_leading_rows.
tags <ARRAY<STRUCT<STRING, STRING>>>

Uma matriz de etiquetas de IAM para a tabela, expressa como pares de chave-valor. A chave deve ser o nome da chave com espaço de nomes, e o valor deve ser o nome abreviado.
time_zone

STRING

(Pré-visualizar)

Fuso horário predefinido que é aplicado ao analisar valores de data/hora que não têm um fuso horário específico.

Verifique os nomes de fusos horários válidos.

Se este valor não estiver presente, os valores de data/hora sem um fuso horário específico são analisados através do fuso horário predefinido UTC.

Aplica-se a dados CSV e JSON.
date_format

STRING

(Pré-visualizar)

Elementos de formato que definem como os valores DATE são formatados nos ficheiros de entrada (por exemplo, MM/DD/YYYY).

Se este valor estiver presente, este formato é o único formato DATE compatível. A deteção automática de esquemas também decide o tipo de coluna DATE com base neste formato, em vez do formato existente.

Se este valor não estiver presente, o campo DATE é analisado com os formatos predefinidos.

Aplica-se a dados CSV e JSON.
datetime_format

STRING

(Pré-visualizar)

Elementos de formato que definem como os valores DATETIME são formatados nos ficheiros de entrada (por exemplo, MM/DD/YYYY HH24:MI:SS.FF3).

Se este valor estiver presente, este formato é o único formato DATETIME compatível. A deteção automática do esquema também decide o tipo de coluna DATETIME com base neste formato, em vez do formato existente.

Se este valor não estiver presente, o campo DATETIME é analisado com os formatos predefinidos.

Aplica-se a dados CSV e JSON.
time_format

STRING

(Pré-visualizar)

Format elements que definem como os valores TIME são formatados nos ficheiros de entrada (por exemplo, HH24:MI:SS.FF3).

Se este valor estiver presente, este formato é o único formato TIME compatível. A deteção automática do esquema também decide o tipo de coluna TIME com base neste formato, em vez do formato existente.

Se este valor não estiver presente, o campo TIME é analisado com os formatos predefinidos.

Aplica-se a dados CSV e JSON.
timestamp_format

STRING

(Pré-visualizar)

Elementos de formato que definem como os valores de TIMESTAMP são formatados nos ficheiros de entrada (por exemplo, MM/DD/YYYY HH24:MI:SS.FF3).

Se este valor estiver presente, este formato é o único formato de DATA/HORA compatível. A deteção automática do esquema também decide o tipo de coluna TIMESTAMP com base neste formato, em vez do formato existente.

Se este valor não estiver presente, o campo TIMESTAMP é analisado com os formatos predefinidos.

Aplica-se a dados CSV e JSON.
uris

Para tabelas externas, incluindo tabelas de objetos, que não sejam tabelas do Bigtable:

ARRAY<STRING>

Uma matriz de URIs totalmente qualificados para as localizações de dados externos. Cada URI pode conter um asterisco (*) carácter universal, que tem de aparecer após o nome do contentor. Quando especifica uris valores que segmentam vários ficheiros, todos esses ficheiros têm de partilhar um esquema compatível.

Os exemplos seguintes 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 usar como uma origem de dados. Só pode 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 o artigo Obtenha o URI do Bigtable.

Exemplos

Exemplo 1:

O exemplo seguinte obtém os tempos de expiração predefinidos das tabelas para todas as tabelas em mydataset no seu projeto predefinido (myproject) consultando a vista INFORMATION_SCHEMA.TABLE_OPTIONS.

Para executar a consulta num projeto que não seja o seu projeto predefinido, 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.

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

O resultado é 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" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+

Exemplo 2:

O exemplo seguinte obtém metadados sobre todas as tabelas em mydataset que contêm dados de teste. A consulta usa os valores na opção description para encontrar tabelas que contenham "teste" em qualquer parte da descrição. mydataset está no seu projeto predefinido: myproject.

Para executar a consulta num projeto que não seja o projeto predefinido, 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 é 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"  |
  +----------------+---------------+------------+-------------+-------------+--------------+

COLUMNS visualização

Quando consulta a vista INFORMATION_SCHEMA.COLUMNS, os resultados da consulta contêm uma linha para cada coluna (campo) numa tabela.

A vista 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 da vista também é conhecido como tableId
COLUMN_NAME STRING O nome da coluna
ORDINAL_POSITION INT64 O desvio indexado a 1 da coluna na tabela; se for uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE, o valor é NULL
IS_NULLABLE STRING YES ou NO, consoante o 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, consoante a coluna seja uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE
IS_UPDATABLE STRING O valor é sempre NULL
IS_SYSTEM_DEFINED STRING YES ou NO, consoante a coluna seja uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES ou NO, consoante a coluna seja uma coluna de partição
CLUSTERING_ORDINAL_POSITION INT64 O desvio com índice 1 da coluna nas colunas de agrupamento da tabela; o valor é NULL se a tabela não for uma tabela agrupada
COLLATION_NAME STRING O nome da especificação de ordenação se existir; caso contrário, NULL

Se for transmitido um STRING ou um ARRAY<STRING> , a especificação de ordenação é devolvida se existir; caso contrário , é devolvido NULL
COLUMN_DEFAULT STRING O valor predefinido da coluna, se existir; caso contrário, o valor é NULL
ROUNDING_MODE STRING O modo de arredondamento usado para valores escritos no campo se o respetivo tipo for um NUMERIC ou BIGNUMERIC parametrizado; caso contrário, o valor é NULL
POLICY_TAGS ARRAY<STRING> A lista de etiquetas de políticas anexadas à coluna

Exemplos

O exemplo seguinte obtém metadados da INFORMATION_SCHEMA.COLUMNSvista para a tabela population_by_zip_2010 no conjunto de dados census_bureau_usa. Este conjunto de dados faz parte do programa de conjuntos de dados públicos do BigQuery.

Uma vez que a tabela que está a consultar se encontra noutro projeto, o projeto bigquery-public-data, adiciona o ID 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 seguintes colunas são excluídas dos resultados da consulta porque estão atualmente reservadas para utilização futura:

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

O resultado é 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 | policy_tags |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+

COLUMN_FIELD_PATHS visualização

Quando consulta a vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, os resultados da consulta contêm uma linha para cada coluna aninhada numa coluna RECORD (ou STRUCT).

A vista 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 da vista também é conhecido como tableId
COLUMN_NAME STRING O nome da coluna
FIELD_PATH STRING O caminho para uma coluna aninhada numa coluna `RECORD` ou `STRUCT`
DATA_TYPE STRING O tipo de dados do GoogleSQL da coluna
DESCRIPTION STRING A descrição da coluna
COLLATION_NAME STRING O nome da especificação de ordenação se existir; caso contrário, NULL

Se for transmitido um campo STRING, ARRAY<STRING> ou STRING num STRUCT, a especificação de ordenação é devolvida se existir; caso contrário, NULL é devolvido
ROUNDING_MODE STRING O modo de arredondamento usado quando aplica a precisão e a escala aos valores NUMERIC ou BIGNUMERIC parametrizados; caso contrário, o valor é NULL
POLICY_TAGS ARRAY<STRING> A lista de etiquetas de políticas anexadas à coluna

Exemplos

O exemplo seguinte obtém metadados da vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS para a tabela commits no conjunto de dados github_repos. Este conjunto de dados faz parte do programa de conjuntos de dados públicos do BigQuery.

Uma vez que a tabela que está a consultar se encontra noutro projeto, o projeto bigquery-public-data, adiciona o ID 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 aninhadas e repetidas:

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

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

INFORMATION_SCHEMA 
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 é semelhante ao seguinte. Para facilitar a leitura, algumas colunas são excluídas do resultado.

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

TABLE_STORAGE visualização

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

Nome da coluna Tipo de dados Valor
PROJECT_ID STRING O ID do projeto que contém o conjunto de dados.
PROJECT_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 vista materializada, também conhecido como datasetId.
TABLE_NAME STRING O nome da tabela ou da vista 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 na vista materializada.
TOTAL_PARTITIONS INT64 O número de partições presentes na tabela ou na vista materializada. As tabelas não particionadas devolvem 0.
TOTAL_LOGICAL_BYTES INT64 O número total de bytes lógicos (não comprimidos) na tabela ou na vista materializada.
ACTIVE_LOGICAL_BYTES INT64 Número de bytes lógicos (não comprimidos) com menos de 90 dias.
LONG_TERM_LOGICAL_BYTES INT64 Número de bytes lógicos (não comprimidos) 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 (comprimidos) usados para armazenamento, incluindo bytes ativos, a longo prazo e de viagem no tempo (dados eliminados ou alterados). Os bytes de segurança (dados eliminados ou alterados retidos após o período de recuperação) não estão incluídos.
ACTIVE_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) com menos de 90 dias, incluindo bytes de viagem no tempo (dados eliminados ou alterados).
LONG_TERM_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) com mais de 90 dias.
TIME_TRAVEL_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) usados pelo armazenamento de viagem no tempo (dados eliminados ou alterados).
STORAGE_LAST_MODIFIED_TIME TIMESTAMP A hora mais recente em que os dados foram escritos na tabela.
DELETED BOOLEAN Indica se a tabela foi eliminada ou não.
TABLE_TYPE STRING O tipo de tabela. Por exemplo, BASE TABLE.
MANAGED_TABLE_TYPE STRING Esta coluna está em pré-visualização. O tipo gerido da tabela. Por exemplo, NATIVE ou BIGLAKE.
FAIL_SAFE_PHYSICAL_BYTES INT64 Número de bytes físicos (comprimidos) usados pelo armazenamento à prova de falhas (dados eliminados ou alterados).
LAST_METADATA_INDEX_REFRESH_TIME TIMESTAMP A hora da última atualização do índice de metadados da tabela.
TABLE_DELETION_REASON STRING Motivo da eliminação da tabela se o campo DELETED for verdadeiro. Os valores possíveis são os seguintes:
  • TABLE_EXPIRATION: tabela eliminada após o tempo de validade definido
  • DATASET_DELETION: conjunto de dados eliminado pelo utilizador
  • USER_DELETED: tabela foi eliminada pelo utilizador
TABLE_DELETION_TIME TIMESTAMP A hora de eliminação da tabela.

Exemplos

Exemplo 1:

O exemplo seguinte mostra o total de bytes lógicos faturados para o projeto atual.

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

O resultado é semelhante ao seguinte:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Exemplo 2:

O exemplo seguinte mostra diferentes bytes de armazenamento em GiB ao nível dos conjuntos de dados para o projeto atual.

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

O exemplo seguinte mostra como prever a diferença de preços por conjunto de dados entre os modelos de faturação lógicos e físicos para os próximos 30 dias. Este exemplo pressupõe que a utilização de armazenamento futura é constante nos próximos 30 dias a partir do momento em que a consulta foi executada. Tenha em atenção que a previsão está limitada às tabelas base e exclui todos os outros tipos de tabelas num conjunto de dados.

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

  1. Abra a página do BigQuery na Google Cloud consola.

    Aceda à página do BigQuery

  2. Introduza a seguinte consulta GoogleSQL na caixa Editor de consultas. INFORMATION_SCHEMA requer a sintaxe GoogleSQL. O GoogleSQL é a sintaxe predefinida na Google Cloud consola.

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

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

  3. Clique em Executar.

O resultado é semelhante ao seguinte:

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

Liste tabelas num conjunto de dados

Pode listar tabelas em conjuntos de dados das seguintes formas:

  • Usar a Google Cloud consola.
  • Usando a ferramenta de linhas de comando bq comando bq ls.
  • Chamar o método da API tables.list.
  • Usando as bibliotecas cliente.

Autorizações necessárias

No mínimo, para listar tabelas num conjunto de dados, tem de ter autorizações bigquery.tables.list. As seguintes funções do IAM predefinidas incluem autorizações bigquery.tables.list:

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

Para mais informações sobre as funções e as autorizações do IAM no BigQuery, consulte o artigo Controlo de acesso.

Listar tabelas

Para listar as tabelas num conjunto de dados:

Consola

  1. Na Google Cloud consola, no painel de navegação, clique no seu conjunto de dados para o expandir. São apresentadas as tabelas e as vistas no conjunto de dados.

  2. Percorra a lista para ver as tabelas no conjunto de dados. As tabelas e as vistas 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. A flag --format pode ser usada para controlar o resultado. Se estiver a listar tabelas num projeto que não seja o seu projeto predefinido, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

    As flags adicionais incluem:

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

    Onde:

    • integer é um número inteiro que representa o número de tabelas a listar.
    • project_id é o ID do seu projeto.
    • dataset é o nome do conjunto de dados.

    Quando executa o comando, o campo Type apresenta TABLE ou VIEW. Por exemplo:

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

    Exemplos:

    Introduza o seguinte comando para listar as tabelas no conjunto de dados mydataset no seu projeto predefinido. 

       bq ls --format=pretty mydataset

    Introduza o seguinte comando para devolver mais do que a saída predefinida de 50 tabelas do mydataset. mydataset está no seu projeto predefinido. 

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

    Introduza o seguinte comando para listar as tabelas no conjunto de dados mydataset em myotherproject. 

       bq ls --format=pretty myotherproject:mydataset

    3. API

    Para listar tabelas através da API, chame o método tables.list.

    C#

    Antes de experimentar este exemplo, siga as C#instruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API C# BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as PHPinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API PHP BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Rubyinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Ruby BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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

Histórico da tabela de auditoria

Pode auditar o histórico das tabelas do BigQuery consultando os registos de auditoria do Google Cloud no Explorador de registos. Estes registos ajudam a monitorizar quando as tabelas foram criadas, atualizadas ou eliminadas, e a identificar o utilizador ou a conta de serviço que fez as alterações.

Autorizações necessárias

Para procurar registos de auditoria, precisa da função roles/logging.privateLogViewer Para mais informações sobre as funções e as autorizações da IAM no Cloud Logging, consulte o artigo Controlo de acesso com a IAM.

Obtenha dados de auditoria

Pode aceder às informações de auditoria a partir da Google Cloud consolagcloud, da linha de comandos, da API REST e de todos os idiomas suportados através de bibliotecas de cliente. O filtro de registo mostrado no exemplo seguinte pode ser usado independentemente do método usado.

  1. Na Google Cloud consola, aceda à página Registo.

    Aceda a Registo

  2. Use a seguinte consulta para aceder aos dados de auditoria:

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

Substitua o seguinte:

  • PROJECT_ID: o projeto que contém conjuntos de dados e tabelas nos quais tem interesse.
  • STARTING_TIMESTAMP: os registos mais antigos que quer ver. Use o formato ISO 8601, como 2025-01-01 ou 2025-02-03T04:05:06Z.
  • DATASET_ID: o conjunto de dados pelo qual quer filtrar.

Interpretação dos resultados

No painel de resultados do Logs Explorer, expanda a entrada na qual tem interesse e, de seguida, clique em Expandir campos aninhados para mostrar a mensagem completa.

A entrada de registo contém apenas um dos seguintes objetos para indicar a operação realizada:

  • protoPayload.metadata.tableCreation: foi criada uma tabela.
  • protoPayload.metadata.tableChange: os metadados da tabela foram alterados, como a atualização do esquema, a alteração da descrição ou a substituição da tabela.
  • protoPayload.metadata.tableDeletion: uma tabela foi eliminada.

O conteúdo destes objetos descreve a ação pedida. Para uma descrição detalhada, consulte BigQueryAuditMetadata.

Explicação da consulta

  • logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity": Esta linha filtra os registos de auditoria da atividade de administrador no seu Google Cloud projeto. Estes registos registam chamadas API e ações que modificam a configuração ou os metadados dos seus recursos.
  • resource.type = "bigquery_dataset": isto restringe a pesquisa a eventos relacionados com conjuntos de dados do BigQuery, onde as operações de tabelas são registadas.
  • timestamp >= "STARTING_TIMESTAMP": filtra as entradas do registo para mostrar apenas as criadas na data/hora especificada ou após esta.
  • protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog": Garante que a mensagem de registo está em conformidade com a estrutura padrão do registo de auditoria do Cloud.
  • ( ... ): este bloco agrupa condições para encontrar diferentes tipos de eventos de tabelas, conforme descrito na secção anterior. O operador :* indica que a chave tem de estar presente. Se tiver interesse apenas num evento, como a criação de tabelas, remova as condições desnecessárias deste bloco.

  • protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/": Seleciona entradas de registo correspondentes a tabelas contidas no conjunto de dados especificado. O operador de dois pontos (:) executa uma pesquisa de subcadeia de carateres.

    • Para filtrar entradas de uma única tabela, substitua a condição pela seguinte: protoPayload.resourceName = "projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_NAME".
    • Para incluir todas as tabelas em todos os conjuntos de dados no projeto específico, remova esta condição.

Para mais informações sobre a filtragem de registos, consulte a linguagem de consulta de registos.

Segurança da mesa

Para controlar o acesso a tabelas no BigQuery, consulte o artigo Controle o acesso a recursos com a IAM.

O que se segue?

Experimente

Se está a usar o Google Cloud pela primeira vez, crie uma conta para avaliar o desempenho do BigQuery em cenários reais. Os novos clientes também recebem 300 USD em créditos gratuitos para executar, testar e implementar cargas de trabalho.

Experimentar o BigQuery gratuitamente