Como gerenciar tabelas

Neste documento, você verá como gerenciar tabelas no BigQuery das seguintes maneiras:

Atualizar os seguintes itens de uma tabela:
- Prazo de validade
- Descrição
- Definição do esquema
- Rótulos
Renomear (copiar) uma tabela
Copiar uma tabela
Excluir uma tabela
Restaurar uma tabela excluída

Para mais informações sobre como criar e usar tabelas, consulte Como criar e usar tabelas. A página inclui como receber informações sobre tabelas, como listá-las e como controlar o acesso aos dados delas.

Como atualizar propriedades da tabela

É possível atualizar estas propriedades:

Permissões necessárias

Para atualizar uma tabela, você precisa ter pelo menos as permissões bigquery.tables.update e bigquery.tables.get. Os seguintes papéis predefinidos de IAM incluem as permissões bigquery.tables.update e bigquery.tables.get:

bigquery.dataEditor
bigquery.dataOwner
bigquery.admin

Além disso, se um usuário tiver permissões bigquery.datasets.create ao criar um conjunto de dados, será concedido o acesso bigquery.dataOwner. Com o acesso de bigquery.dataOwner, os usuários conseguem atualizar as propriedades de tabela dos conjuntos de dados criados por eles.

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

Como atualizar a descrição de uma tabela

É possível atualizar a descrição de uma tabela das seguintes formas:

Usando o Console do Cloud ou a IU da Web clássica do BigQuery
use uma instrução DDL ALTER TABLE;
use o comando bq update da ferramenta de linha de comando bq;
fazendo uma chamada do método de API tables.patch;
Usando as bibliotecas de cliente

Para atualizar a descrição de uma tabela:

Console

Não é possível adicionar uma descrição durante a criação de uma tabela no Console do Cloud. No entanto, depois de criá-la, é possível adicionar a descrição na página Detalhes.

No painel Recursos, selecione sua tabela.
Abaixo do Editor de consultas, clique em Detalhes.
Na seção Descrição, clique no ícone de lápis para editar a descrição.
Insira uma descrição na caixa e clique em Atualizar para salvar.

DDL

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

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

Para atualizar a descrição da tabela por meio de uma instrução DDL no Console do Cloud:

Clique em Escrever nova consulta.

Digite a instrução DDL na área de texto do Editor de consultas.

 ALTER TABLE mydataset.mytable
 SET OPTIONS (
   description="Description of mytable"
 )

Clique em Executar.

IU clássica

No painel de navegação, selecione sua tabela.
Na página Detalhes da tabela, clique em Detalhes.
Na seção Descrição, clique em Descrever esta tabela para abrir a caixa de descrição.
Digite uma descrição na caixa. Ao clicar fora da caixa, o texto é salvo.

bq

Use o comando bq update com a sinalização --description. Se você estiver atualizando uma tabela em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: project_id:dataset.

bq update \
--description "description" \
project_id:dataset.table

Substitua:

description: o texto que descreve a tabela entre aspas.
project_id: o ID do projeto.
dataset: o nome do conjunto de dados com a tabela que você está atualizando.
table: o nome da tabela que você está atualizando.

Exemplos:

Digite o seguinte comando para alterar a descrição de mytable em mydataset para "Descrição do mytable". mydataset está no projeto padrão.

bq update --description "Description of mytable" mydataset.mytable

Digite o seguinte comando para alterar a descrição de mytable em mydataset para "Descrição do mytable". mydataset está em myotherproject, e não no projeto padrão.

bq update \
--description "Description of mytable" \
myotherproject:mydataset.mytable

API

Chame o método tables.patch e use a propriedade description no recurso da tabela para atualizar a descrição da tabela. Como o método tables.update substitui todo o recurso da tabela, é melhor usar o método tables.patch.

Go

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

Ver no GitHub Feedback

import (
	"context"
	"fmt"

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

// updateTableDescription demonstrates how to fetch a table's metadata and updates the Description metadata.
func updateTableDescription(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()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		Description: "Updated description.",
	}
	if _, err = tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

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

Ver no GitHub (em inglês) Feedback

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

public class UpdateTableDescription {

  public static void runUpdateTableDescription() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String newDescription = "this is the new table description";
    updateTableDescription(datasetName, tableName, newDescription);
  }

  public static void updateTableDescription(
      String datasetName, String tableName, String newDescription) {
    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();

      Table table = bigquery.getTable(datasetName, tableName);
      bigquery.update(table.toBuilder().setDescription(newDescription).build());
      System.out.println("Table description updated successfully to " + newDescription);
    } catch (BigQueryException e) {
      System.out.println("Table description was not updated \n" + e.toString());
    }
  }
}

Python

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

Configure a propriedade Table.description e chame Client.update_table() para enviar a atualização à API.

Ver no GitHub

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, dataset_id)
# table_ref = dataset_ref.table('my_table')
# table = client.get_table(table_ref)  # API request

assert table.description == "Original description."
table.description = "Updated description."

table = client.update_table(table, ["description"])  # API request

assert table.description == "Updated description."

Como atualizar o prazo de validade da tabela

É possível configurar o prazo de validade padrão da tabela no nível do conjunto de dados ou defini-lo quando a tabela for criada. Muitas vezes, ele é mencionado como "tempo de vida" ou TTL, na sigla em inglês.

Se você fizer isso durante a criação da tabela, a validade padrão da tabela do conjunto de dados será ignorada. Se você não a configurar no nível do conjunto de dados e não defini-la quando a tabela for criada, a tabela nunca expirará, e você precisará excluí-la manualmente.

É possível atualizar o prazo de validade de uma tabela a qualquer momento após criá-la. Faça isso de uma das seguintes formas:

Usando o Console do Cloud ou a IU da Web clássica do BigQuery
use uma instrução DDL ALTER TABLE;
use o comando bq update da ferramenta de linha de comando bq;
fazendo uma chamada do método de API tables.patch;
Usando as bibliotecas de cliente

Para atualizar o prazo de validade de uma tabela:

Console

Não é possível adicionar um prazo de validade durante a criação de uma tabela no Console do Cloud. No entanto, depois de criá-la, é possível adicionar ou atualizar a validade da tabela na página Detalhes da tabela.

No painel Recursos, selecione sua tabela.
Abaixo do Editor de consultas, clique em Detalhes.
Clique no ícone de lápis ao lado de Informações da tabela.
Em Validade da tabela, selecione Especificar data. Em seguida, selecione a data de validade usando o widget de calendário.
Clique em Atualizar para salvar. O prazo de validade atualizado é exibido na seção Informações da tabela.

DDL

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

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

Para atualizar o prazo de validade por meio de uma instrução DDL no Console do Cloud:

Clique em Escrever nova consulta.

Digite a instrução DDL na área de texto do Editor de consultas.

 ALTER TABLE mydataset.mytable
 SET OPTIONS (
   -- Sets table expiration to timestamp 2025-02-03 12:34:56
   expiration_timestamp=TIMESTAMP "2025-02-03 12:34:56"
 )

Clique em Executar.

IU clássica

No painel de navegação, selecione sua tabela.
Na página Table Details, clique em Details.
Em Prazo de validade, clique em Editar.
Na caixa de diálogo Atualizar a validade, selecione Em e insira o prazo de validade em dias.
Clique em OK. O prazo de validade atualizado é exibido na página Detalhes.

bq

Use o comando bq update com a sinalização --expiration. Se você estiver atualizando uma tabela em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: project_id:dataset.

bq update \
--expiration integer \
project_id:dataset.table

Substitua:

integer: a vida útil padrão (em segundos) da tabela. O valor mínimo é de 3.600 segundos (uma hora). O tempo de expiração é avaliado para a hora atual mais o valor inteiro. Se você especificar como 0, a validade da tabela será removida e ela nunca irá expirar. Tabelas sem prazo de validade precisam ser excluídas manualmente.
project_id: o ID do projeto.
dataset: o nome do conjunto de dados com a tabela que você está atualizando.
table: o nome da tabela que você está atualizando.

Exemplos:

Insira o seguinte comando para atualizar o prazo de validade de mytable em mydataset para 5 dias (432.000 segundos). mydataset está em seu projeto padrão.

bq update --expiration 432000 mydataset.mytable

Insira o seguinte comando para atualizar o prazo de validade de mytable em mydataset para 5 dias (432.000 segundos). mydataset está em myotherproject, e não no projeto padrão.

bq update --expiration 432000 myotherproject:mydataset.mytable

API

Chame o método tables.patch e use a propriedade expirationTime no recurso da tabela para atualizar a validade da tabela em milissegundos. Como o método tables.update substitui todo o recurso da tabela, é melhor usar o método tables.patch.

Go

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"time"

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

// updateTableExpiration demonstrates setting the table expiration of a table to a specific point in time
// in the future, at which time it will be deleted.
func updateTableExpiration(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()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		ExpirationTime: time.Now().Add(time.Duration(5*24) * time.Hour), // table expiration in 5 days.
	}
	if _, err = tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Ver no GitHub (em inglês) Feedback

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 java.util.concurrent.TimeUnit;

public class UpdateTableExpiration {

  public static void runUpdateTableExpiration() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    // Update table expiration to one day.
    Long newExpiration = TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS);
    updateTableExpiration(datasetName, tableName, newExpiration);
  }

  public static void updateTableExpiration(
      String datasetName, String tableName, Long newExpiration) {
    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();

      Table table = bigquery.getTable(datasetName, tableName);
      bigquery.update(table.toBuilder().setExpirationTime(newExpiration).build());

      System.out.println("Table expiration updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Table expiration was not updated \n" + e.toString());
    }
  }
}

Python

Configure a propriedade Table.expires e chame Client.update_table() para enviar a atualização à API.

Ver no GitHub

import datetime
import pytz

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, dataset_id)
# table_ref = dataset_ref.table('my_table')
# table = client.get_table(table_ref)  # API request

assert table.expires is None

# set table to expire 5 days from now
expiration = datetime.datetime.now(pytz.utc) + datetime.timedelta(days=5)
table.expires = expiration
table = client.update_table(table, ["expires"])  # API request

# expiration is stored in milliseconds
margin = datetime.timedelta(microseconds=1000)
assert expiration - margin <= table.expires <= expiration + margin

Como atualizar a definição de esquema de uma tabela

Para instruções, consulte Como modificar esquemas de tabela.

Como renomear uma tabela

No momento, não é possível alterar o nome de uma tabela atual. Porém, caso seja necessário, siga as etapas para copiar a tabela. Ao especificar a tabela de destino na operação de cópia, use o novo nome da tabela.

Como copiar uma tabela

É possível copiar uma tabela das seguintes formas:

Use o Console do Cloud ou a IU da Web clássica do BigQuery
use o comando bq da ferramenta de linha de comando bq cp;
fazendo uma chamada do método de API jobs.insert e configurando um job copy;
Usando as bibliotecas de cliente

Permissões necessárias

Para copiar tabelas e partições, é necessário ter pelo menos as permissões a seguir:

No conjunto de dados de origem:

bigquery.tables.get
bigquery.tables.getData

No conjunto de dados de destino:

bigquery.tables.create para criar a cópia da tabela ou da partição no conjunto de dados de destino.

Os seguintes papéis predefinidos de IAM incluem as permissões bigquery.tables.create, bigquery.tables.get e bigquery.tables.getData:

bigquery.dataEditor
bigquery.dataOwner
bigquery.admin

Além disso, para executar o job copy, é necessário ter permissões bigquery.jobs.create.

Os seguintes papéis predefinidos do IAM incluem as permissões bigquery.jobs.create:

bigquery.user
bigquery.jobUser
bigquery.admin

Além disso, se um usuário tiver permissões bigquery.datasets.create ao criar um conjunto de dados, será concedido o acesso bigquery.dataOwner. Com o acesso de bigquery.dataOwner, o usuário consegue copiar tabelas e partições no conjunto de dados. No entanto, se o usuário não for o criador do conjunto de dados de destino, precisará receber acesso a ele.

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

Limitações ao copiar tabelas

Os jobs de cópia de tabelas estão sujeitos às limitações a seguir:

Ao fazer a cópia, o nome da tabela de destino precisa aderir às mesmas convenções de nomenclatura da criação de tabelas.
As cópias de tabelas estão sujeitas às políticas de cota do BigQuery nos jobs de cópia.
Ao usar o Console do Cloud ou a IU da Web clássica do BigQuery para copiar uma tabela, não é possível substituir uma tabela atual no conjunto de dados de destino. A tabela precisa ter um nome exclusivo nesse conjunto.
Ao copiar tabelas, o conjunto de dados de destino e o que contém a tabela a ser copiada precisam estar no mesmo local. Por exemplo, não é possível copiar uma tabela de um conjunto de dados que tem base na UE e gravá-la em um conjunto que tem base nos EUA.
A cópia de várias tabelas de origem em uma tabela de destino não é compatível com o Console do Cloud ou com a IU da Web clássica do BigQuery.
Ao copiar várias tabelas de origem para uma tabela de destino usando a API ou a ferramenta de linha de comando bq, todas as tabelas de origem precisam ter esquemas idênticos.

Como copiar uma única tabela de origem

É possível copiar uma tabela das seguintes formas:

Use o Console do Cloud ou a IU da Web clássica do BigQuery
use o comando bq da ferramenta de linha de comando bq cp;
fazendo uma chamada do método de API jobs.insert, configurando um job copy e especificando a propriedade sourceTable;
Usando as bibliotecas de cliente

O Console do Cloud e a IU da Web clássica do BigQuery aceitam apenas uma tabela de origem e uma de destino em um job de cópia. Para copiar vários arquivos de origem para uma tabela de destino, você precisa usar a ferramenta de linha de comando bq ou a API.

Para copiar uma única tabela de origem:

Console

Selecione a tabela que você quer copiar no painel Recursos.
Abaixo do Editor de consultas, clique em Copiar tabela.
Na caixa de diálogo Copiar tabela, em Destino, siga estas etapas:
- Em Nome do projeto, escolha o projeto que armazenará a tabela copiada.
- Em Nome do conjunto de dados, selecione o conjunto de dados em que você quer armazenar a tabela copiada. Os conjuntos de dados de origem e destino precisam estar no mesmo local.
- Em Nome da tabela, insira um nome para a tabela nova. Ele precisa ser exclusivo no conjunto de dados de destino. O nome da tabela pode conter até 1.024 caracteres, sendo eles a-z, A-Z, 0-9 ou _ (caractere de sublinhado). Não é possível substituir uma tabela atual do conjunto de dados de destino usando o Console do Cloud.
Clique em Copiar para iniciar o job de cópia.

IU clássica

Clique no ícone do menu de exibição ao lado da tabela que você quer copiar e clique em Copiar tabela.
Na caixa de diálogo Copiar tabela:
- Em Projeto de destino, escolha o projeto que armazenará a tabela copiada.
- Em Conjunto de dados de destino, selecione o conjunto de dados em que você quer armazenar a tabela copiada. Os conjuntos de dados de origem e destino precisam estar no mesmo local.
- Em Tabela de destino, insira um nome para a tabela nova. Ele precisa ser exclusivo no conjunto de dados de destino. O nome da tabela pode conter até 1.024 caracteres, sendo eles a-z, A-Z, 0-9 ou _ (caractere de sublinhado). Não é possível substituir uma tabela atual no conjunto de dados de destino por meio da IU da Web do BigQuery.
Clique em OK para iniciar o job de cópia.

bq

Emita o comando bq cp. É possível usar sinalizações opcionais para controlar a disposição de gravação da tabela de destino:

-a ou --append_table anexa os dados das tabelas de origem a uma tabela atual no conjunto de dados de destino.
-f ou --force substitui uma tabela atual do conjunto de dados de destino e não solicita confirmação.
-n ou --no_clobber retorna a mensagem de erro a seguir quando a tabela já está no conjunto de dados de destino: Table 'project_id:dataset.table' already exists, skipping.. Se -n não for especificado, o comportamento padrão é solicitar que o usuário escolha se quer substituir a tabela de destino.
--destination_kms_key é a chave do Cloud KMS gerenciada pelo cliente que é usada para criptografar a tabela de destino.

--destination_kms_key não é demonstrado aqui. Para mais informações, consulte Como proteger dados com chaves do Cloud Key Management Service.

Se o conjunto de dados de origem ou de destino estiver em um projeto diferente do padrão, adicione o ID do projeto aos nomes dos conjuntos de dados no seguinte formato: project_id:dataset.

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

bq --location=location cp \
-a -f -n \
project_id:dataset.source_table \
project_id:dataset.destination_table

Substitua:

location: o nome do seu local; A sinalização --location é opcional. Por exemplo, se estiver usando o BigQuery na região de Tóquio, defina o valor da sinalização como asia-northeast1. Defina um valor padrão para a unidade usando o arquivo .bigqueryr.
project_id: o ID do projeto.
dataset: o nome do conjunto de dados de origem ou de destino.
source_table: a tabela que você está copiando.
destination_table: o nome da tabela no conjunto de dados de destino.

Exemplos:

Digite o seguinte comando para copiar mydataset.mytable para mydataset2.mytable2. Os dois conjuntos de dados estão no projeto padrão.

bq cp mydataset.mytable mydataset2.mytable2

Digite o seguinte comando para copiar mydataset.mytable e substituir uma tabela de destino com o mesmo nome. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está em myotherproject. O atalho -f é usado para substituir a tabela de destino sem enviar uma solicitação.

bq cp -f \
mydataset.mytable \
myotherproject:myotherdataset.mytable

Insira o comando a seguir para copiar mydataset.mytable e retornar um erro caso o conjunto de dados de destino contenha uma tabela com o mesmo nome. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está em myotherproject. O atalho -n é usado para evitar a substituição de uma tabela com o mesmo nome.

bq cp -n \
mydataset.mytable \
myotherproject:myotherdataset.mytable

Insira o seguinte comando para copiar mydataset.mytable e anexar os dados a uma tabela de destino com o mesmo nome. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está em myotherproject. O atalho - a é usado para anexar à tabela de destino.

bq cp -a mydataset.mytable myotherproject:myotherdataset.mytable

API

É possível copiar uma tabela atual por meio da API chamando o método bigquery.jobs.insert e configurando um job copy. Especifique seu local na propriedade location da seção jobReference do recurso do job.

Especifique os valores a seguir na configuração do job:

"copy": {
      "sourceTable": {       // Required
        "projectId": string, // Required
        "datasetId": string, // Required
        "tableId": string    // Required
      },
      "destinationTable": {  // Required
        "projectId": string, // Required
        "datasetId": string, // Required
        "tableId": string    // Required
      },
      "createDisposition": string,  // Optional
      "writeDisposition": string,   // Optional
    },

Onde sourceTable fornece informações sobre a tabela a ser copiada, destinationTable fornece informações sobre a tabela nova, createDisposition especifica se a tabela será criada caso não exista e writeDisposition especifica se será necessário substituir ou anexar a uma tabela atual.

C#

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

Ver no GitHub Feedback


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCopyTable
{
    public void CopyTable(
        string projectId = "your-project-id",
        string destinationDatasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference sourceTableRef = new TableReference()
        {
            TableId = "shakespeare",
            DatasetId = "samples",
            ProjectId = "bigquery-public-data"
        };
        TableReference destinationTableRef = client.GetTableReference(
            destinationDatasetId, "destination_table");
        BigQueryJob job = client.CreateCopyJob(
            sourceTableRef, destinationTableRef)
            .PollUntilCompleted();  // Wait for the job to complete.
        // Retrieve destination table
        BigQueryTable destinationTable = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Copied {destinationTable.Resource.NumRows} rows from table "
            + $"{sourceTableRef.DatasetId}.{sourceTableRef.TableId} "
            + $"to {destinationTable.FullyQualifiedId}."
        );
    }
}

Go

Ver no GitHub Feedback

import (
	"context"
	"fmt"

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

// copyTable demonstrates copying a table from a source to a destination, and
// allowing the copy to overwrite existing data by using truncation.
func copyTable(projectID, datasetID, srcID, dstID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// srcID := "sourcetable"
	// dstID := "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	dataset := client.Dataset(datasetID)
	copier := dataset.Table(dstID).CopierFrom(dataset.Table(srcID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.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
	}
	return nil
}

Java

Ver no GitHub (em inglês) Feedback

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

public class CopyTable {

  public static void runCopyTable() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DESTINATION_DATASET_NAME";
    String destinationTableId = "MY_DESTINATION_TABLE_NAME";
    String sourceDatasetName = "MY_SOURCE_DATASET_NAME";
    String sourceTableId = "MY_SOURCE_TABLE_NAME";

    copyTable(sourceDatasetName, sourceTableId, destinationDatasetName, destinationTableId);
  }

  public static void copyTable(
      String sourceDatasetName,
      String sourceTableId,
      String destinationDatasetName,
      String destinationTableId) {
    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 sourceTable = TableId.of(sourceDatasetName, sourceTableId);
      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(destinationTable, sourceTable).build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy table due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

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

Ver no GitHub (em inglês) Feedback

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

async function copyTable() {
  // Copies src_dataset:src_table to dest_dataset:dest_table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const srcDatasetId = "my_src_dataset";
  // const srcTableId = "my_src_table";
  // const destDatasetId = "my_dest_dataset";
  // const destTableId = "my_dest_table";

  // Copy the table contents into another table
  const [job] = await bigquery
    .dataset(srcDatasetId)
    .table(srcTableId)
    .copy(bigquery.dataset(destDatasetId).table(destTableId));

  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

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

Ver no GitHub (em inglês) Feedback

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $sourceTableId   = 'The BigQuery table ID to copy from';
// $destinationTableId = 'The BigQuery table ID to copy to';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$sourceTable = $dataset->table($sourceTableId);
$destinationTable = $dataset->table($destinationTableId);
$copyConfig = $sourceTable->copy($destinationTable);
$job = $sourceTable->runJob($copyConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Table copied successfully' . PHP_EOL);
}

Python

Ver no GitHub Feedback


from google.cloud import bigquery

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

# TODO(developer): Set source_table_id to the ID of the original table.
# source_table_id = "your-project.source_dataset.source_table"

# TODO(developer): Set destination_table_id to the ID of the destination table.
# destination_table_id = "your-project.destination_dataset.destination_table"

job = client.copy_table(source_table_id, destination_table_id)
job.result()  # Wait for the job to complete.

print("A copy of the table created.")

Como copiar várias tabelas de origem

Para copiar várias tabelas de origem para uma tabela de destino:

use o comando bq cp da ferramenta de linha de comando bq;
Fazendo uma chamada do método jobs.insert, configurando um job copy e especificando a propriedade sourceTables
Usando as bibliotecas de cliente

Todas as tabelas de origem precisam ter esquemas idênticos. Apenas uma tabela de destino é permitida.

As tabelas de origem precisam ser especificadas como uma lista separada por vírgulas. Não é possível usar caracteres curingas quando várias tabelas de origem são copiadas.

Para copiar várias tabelas de origem:

Console

No momento, não é possível copiar várias tabelas usando o Console do Cloud.

IU clássica

No momento, não é possível copiar várias tabelas usando a IU da Web clássica do BigQuery.

bq

Emita o comando bq cp e inclua várias tabelas de origem em uma lista separada por vírgulas. É possível usar sinalizações opcionais para controlar a disposição de gravação da tabela de destino:

-a ou --append_table anexa os dados das tabelas de origem a uma tabela atual no conjunto de dados de destino.
-f ou --force substitui uma tabela atual do conjunto de dados de destino e não solicita confirmação.
-n ou --no_clobber retorna a mensagem de erro a seguir quando a tabela já está no conjunto de dados de destino: Table 'project_id:dataset.table' already exists, skipping.. Se -n não for especificado, o comportamento padrão é solicitar que o usuário escolha se quer substituir a tabela de destino.
--destination_kms_key é a chave do Cloud Key Management Service gerenciada pelo cliente que é usada para criptografar a tabela de destino.

--destination_kms_key não é demonstrado aqui. Para mais informações, consulte Como proteger dados com chaves do Cloud Key Management Service.

Se o conjunto de dados de origem ou de destino estiver em um projeto diferente do padrão, adicione o ID do projeto aos nomes dos conjuntos de dados no seguinte formato: project_id:dataset.

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

bq --location=location cp \
-a -f -n \
project_id:dataset.source_table,project_id:dataset.source_table \
project_id:dataset.destination_table

Substitua:

location: o nome do seu local; A sinalização --location é opcional. Por exemplo, se estiver usando o BigQuery na região de Tóquio, defina o valor da sinalização como asia-northeast1. Defina um valor padrão para a unidade usando o arquivo .bigqueryr.
project_id: o ID do projeto.
dataset: o nome do conjunto de dados de origem ou de destino.
source_table: a tabela que você está copiando.
destination_table: o nome da tabela no conjunto de dados de destino.

Exemplos:

Insira o seguinte comando para copiar mydataset.mytable e mydataset.mytable2 para mydataset2.tablecopy. Todos os conjuntos de dados estão no projeto padrão.

bq cp \
mydataset.mytable,mydataset.mytable2 \
mydataset2.tablecopy

Insira o seguinte comando para copiar mydataset.mytable e mydataset.mytable2 para myotherdataset.mytable e para substituir uma tabela de destino com o mesmo nome. O conjunto de dados de destino está em myotherproject, e não no projeto padrão. O atalho -f é usado para substituir a tabela de destino sem enviar uma solicitação.

bq cp -f \
mydataset.mytable,mydataset.mytable2 \
myotherproject:myotherdataset.mytable

Insira o seguinte comando para copiar myproject:mydataset.mytable e myproject:mydataset.mytable2 e retornar um erro caso o conjunto de dados de destino contenha uma tabela com o mesmo nome. O conjunto de dados de destino está em myotherproject. O atalho -n é usado para evitar a substituição de uma tabela com o mesmo nome.

bq cp -n \
myproject:mydataset.mytable,myproject:mydataset.mytable2 \
myotherproject:myotherdataset.mytable

Insira o seguinte comando para copiar mydataset.mytable e mydataset.mytable2 e anexar os dados a uma tabela de destino com o mesmo nome. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está em myotherproject. O atalho -a é usado para anexar à tabela de destino.

bq cp -a \
mydataset.mytable,mydataset.mytable2 \
myotherproject:myotherdataset.mytable

API

Para copiar várias tabelas usando a API, chame o método jobs.insert, configure um job copy da tabela e especifique a propriedade sourceTables.

Especifique sua região na propriedade location da seção jobReference do recurso do job.

Go

Ver no GitHub Feedback

import (
	"context"
	"fmt"

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

// copyMultiTable demonstrates using a copy job to copy multiple source tables into a single destination table.
func copyMultiTable(projectID, srcDatasetID string, srcTableIDs []string, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// srcDatasetID := "sourcedataset"
	// srcTableIDs := []string{"table1","table2"}
	// dstDatasetID = "destinationdataset"
	// dstTableID = "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcDataset := client.Dataset(srcDatasetID)
	dstDataset := client.Dataset(dstDatasetID)
	var tableRefs []*bigquery.Table
	for _, v := range srcTableIDs {
		tableRefs = append(tableRefs, srcDataset.Table(v))
	}
	copier := dstDataset.Table(dstTableID).CopierFrom(tableRefs...)
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.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
	}
	return nil
}

Java

Ver no GitHub (em inglês) Feedback

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;
import java.util.Arrays;

public class CopyMultipleTables {

  public static void runCopyMultipleTables() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DATASET_NAME";
    String destinationTableId = "MY_TABLE_NAME";
    copyMultipleTables(destinationDatasetName, destinationTableId);
  }

  public static void copyMultipleTables(String destinationDatasetName, String destinationTableId) {
    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 destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(
                  destinationTable,
                  Arrays.asList(
                      TableId.of(destinationDatasetName, "table1"),
                      TableId.of(destinationDatasetName, "table2")))
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy tables due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

Ver no GitHub (em inglês) Feedback

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

async function copyTableMultipleSource() {
  // Copy multiple source tables to a given destination.

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

  // Create a client
  const dataset = bigquery.dataset(datasetId);

  const metadata = {
    createDisposition: 'CREATE_NEVER',
    writeDisposition: 'WRITE_TRUNCATE',
  };

  // Create table references
  const table = dataset.table(sourceTable);
  const yourTable = dataset.table(destinationTable);

  // Copy table
  const [apiResponse] = await table.copy(yourTable, metadata);
  console.log(apiResponse.configuration.copy);
}

Python

Ver no GitHub Feedback


from google.cloud import bigquery

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

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

# TODO(developer): Set table_ids to the list of the IDs of the original tables.
# table_ids = ["your-project.your_dataset.your_table_name", ...]

job = client.copy_table(table_ids, dest_table_id)  # Make an API request.
job.result()  # Wait for the job to complete.

print("The tables {} have been appended to {}".format(table_ids, dest_table_id))

Como excluir tabelas

É possível excluir uma tabela das seguintes formas:

Use o Console do Cloud ou a IU da Web clássica do BigQuery
Como usar o comando bq da ferramenta de linha de comando bq rm
Fazendo uma chamada do método de API tables.delete
Usando as bibliotecas de cliente

No momento, só é possível excluir uma tabela por vez.

Ao excluir uma tabela, todos os dados dela também são removidos. Para excluir tabelas automaticamente após um período especificado, defina a validade padrão da tabela para o conjunto de dados ou defina o prazo de validade ao criar a tabela.

Permissões necessárias

Para excluir uma tabela, você precisa ter pelo menos as permissões bigquery.tables.delete e bigquery.tables.get. Os seguintes papéis predefinidos de IAM incluem as permissões bigquery.tables.delete e bigquery.tables.get:

bigquery.dataOwner
bigquery.dataEditor
bigquery.admin

Além disso, se um usuário tiver permissões bigquery.datasets.create ao criar um conjunto de dados, será concedido o acesso bigquery.dataOwner. Com o acesso bigquery.dataOwner, o usuário pode excluir tabelas no conjunto de dados.

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

Como excluir tabelas

Para excluir uma tabela:

Console

Selecione a tabela no painel Recursos. Abaixo do Editor de consultas, clique em Excluir tabela.
Digite o nome da tabela na caixa de diálogo e clique em Excluir para confirmar.

IU clássica

Clique no ícone de seta para baixo ao lado do nome da tabela na barra de navegação e clique em Excluir tabela.
Quando solicitado, clique em OK para confirmar.

bq

Use o comando bq rm com a sinalização --table (ou atalho -t) para excluir uma tabela. Quando você usa a ferramenta de linha de comando bq para remover uma tabela, é necessário confirmar a ação. É possível usar a sinalização --force (ou o atalho -f) para pular a confirmação.

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

bq rm \
-f \
-t \
project_id:dataset.table

Substitua:

project_id: o ID do projeto.
dataset: o nome do conjunto de dados onde está a tabela.
table: o nome da tabela que você está excluindo.

Exemplos:

Digite o seguinte comando para excluir mytable de mydataset. mydataset está no projeto padrão.

bq rm -t mydataset.mytable

Digite o seguinte comando para excluir mytable de mydataset. mydataset está em myotherproject, não no projeto padrão.

bq rm -t myotherproject:mydataset.mytable

Digite o seguinte comando para excluir mytable de mydataset. mydataset está no projeto padrão. O comando usa o atalho -f para ignorar a confirmação.

bq rm -f -t mydataset.mytable

API

Chame o método API tables.delete e especifique a tabela a ser excluída usando o parâmetro tableId.

C#

Ver no GitHub Feedback


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

public class BigQueryDeleteTable
{
    public void DeleteTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        client.DeleteTable(datasetId, tableId);
        Console.WriteLine($"Table {tableId} deleted.");
    }
}

Go

Ver no GitHub Feedback

import (
	"context"
	"fmt"

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

// deleteTable demonstrates deletion of a BigQuery table.
func deleteTable(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()

	table := client.Dataset(datasetID).Table(tableID)
	if err := table.Delete(ctx); err != nil {
		return err
	}
	return nil
}

Java

Ver no GitHub (em inglês) Feedback

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

public class DeleteTable {

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

  public static void deleteTable(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();
      boolean success = bigquery.delete(TableId.of(datasetName, tableName));
      if (success) {
        System.out.println("Table deleted successfully");
      } else {
        System.out.println("Table was not found");
      }
    } catch (BigQueryException e) {
      System.out.println("Table was not deleted. \n" + e.toString());
    }
  }
}

Node.js

Ver no GitHub (em inglês) Feedback

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

async function deleteTable() {
  // Deletes "my_table" from "my_dataset".

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

  // Delete the table
  await bigquery
    .dataset(datasetId)
    .table(tableId)
    .delete();

  console.log(`Table ${tableId} deleted.`);
}

PHP

Ver no GitHub (em inglês) Feedback

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);
$table->delete();
printf('Deleted table %s.%s' . PHP_EOL, $datasetId, $tableId);

Python

Ver no GitHub (em inglês) Feedback


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 fetch.
# table_id = 'your-project.your_dataset.your_table'

# If the table does not exist, delete_table raises
# google.api_core.exceptions.NotFound unless not_found_ok is True.
client.delete_table(table_id, not_found_ok=True)  # Make an API request.
print("Deleted table '{}'.".format(table_id))

Ruby

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

Ver no GitHub Feedback

require "google/cloud/bigquery"

def delete_table dataset_id = "my_dataset_id", table_id = "my_table_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table    = dataset.table table_id

  table.delete

  puts "Table #{table_id} deleted."
end

Como restaurar tabelas excluídas

Você pode cancelar a exclusão de uma tabela em até sete dias após a exclusão (incluindo exclusões explícitas e implícitas pela expiração da tabela). Ao usar a funcionalidade FOR SYSTEM_TIME AS OF, você pode referenciar uma tabela antes do evento de exclusão e copiá-la.

Após sete dias, não é mais possível cancelar a exclusão de uma tabela usando qualquer método, seja FOR SYSTEM_TIME AS OF ou outras maneiras (como um tíquete de suporte).

Como restaurar uma tabela excluída

É possível restaurar uma tabela excluída das seguintes formas:

Como usar o decorador de snapshot @<time> na ferramenta de linha de comando bq
use bibliotecas de cliente.

Console

Não é possível cancelar a exclusão de uma tabela usando o Console do Cloud.

IU clássica

Não é possível cancelar a exclusão de uma tabela usando a IU da Web clássica.

bq

Para cancelar a exclusão de uma tabela, use uma operação de cópia de tabela com o decorador de snapshot @<time>. Primeiro, determine um carimbo de data/hora UNIX em milésimos de segundo de quando a tabela existia. Depois, copie a tabela desse carimbo de data/hora para uma nova tabela. A nova tabela precisa ter um nome diferente da excluída.

(Opcional) Forneça a sinalização --location e defina o valor para seu local.

Por exemplo, digite o seguinte comando para copiar mydataset.mytable no momento 1418864998000 para uma nova tabela mydataset.newtable.

bq cp mydataset.mytable@1418864998000 mydataset.newtable

Para mais informações, consulte Decoradores de tabela no SQL legado.

Go

Ver no GitHub

import (
	"context"
	"fmt"
	"time"

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

// deleteAndUndeleteTable demonstrates how to recover a deleted table by copying it from a point in time
// that predates the deletion event.
func deleteAndUndeleteTable(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()

	ds := client.Dataset(datasetID)
	if _, err := ds.Table(tableID).Metadata(ctx); err != nil {
		return err
	}
	// Record the current time.  We'll use this as the snapshot time
	// for recovering the table.
	snapTime := time.Now()

	// "Accidentally" delete the table.
	if err := client.Dataset(datasetID).Table(tableID).Delete(ctx); err != nil {
		return err
	}

	// Construct the restore-from tableID using a snapshot decorator.
	snapshotTableID := fmt.Sprintf("%s@%d", tableID, snapTime.UnixNano()/1e6)
	// Choose a new table ID for the recovered table data.
	recoverTableID := fmt.Sprintf("%s_recovered", tableID)

	// Construct and run a copy job.
	copier := ds.Table(recoverTableID).CopierFrom(ds.Table(snapshotTableID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.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
	}

	ds.Table(recoverTableID).Delete(ctx)
	return nil
}

Java

Ver no GitHub (em inglês) Feedback

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

// Sample to undeleting a table
public class UndeleteTable {

  public static void runUndeleteTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_TABLE";
    String recoverTableName = "MY_RECOVER_TABLE_TABLE";
    undeleteTable(datasetName, tableName, recoverTableName);
  }

  public static void undeleteTable(String datasetName, String tableName, String recoverTableName) {
    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();

      // "Accidentally" delete the table.
      bigquery.delete(TableId.of(datasetName, tableName));

      // Record the current time.  We'll use this as the snapshot time
      // for recovering the table.
      long snapTime = System.currentTimeMillis();

      // Construct the restore-from tableID using a snapshot decorator.
      String snapshotTableId = String.format("%s@%d", tableName, snapTime);

      // Construct and run a copy job.
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(
                  // Choose a new table ID for the recovered table data.
                  TableId.of(datasetName, recoverTableName),
                  TableId.of(datasetName, snapshotTableId))
              .build();

      Job job = bigquery.create(JobInfo.of(configuration));
      job = job.waitFor();
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("Undelete table recovered successfully.");
      } else {
        System.out.println(
            "BigQuery was unable to copy the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table not found. \n" + e.toString());
    }
  }
}

Node.js

Ver no GitHub (em inglês) Feedback

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

async function undeleteTable() {
  // Undeletes "my_table_to_undelete" from "my_dataset".

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

  /**
   * TODO(developer): Choose an appropriate snapshot point as epoch milliseconds.
   * For this example, we choose the current time as we're about to delete the
   * table immediately afterwards.
   */
  const snapshotEpoch = Date.now();

  // Delete the table
  await bigquery
    .dataset(datasetId)
    .table(tableId)
    .delete();

  console.log(`Table ${tableId} deleted.`);

  // Construct the restore-from table ID using a snapshot decorator.
  const snapshotTableId = `${tableId}@${snapshotEpoch}`;

  // Construct and run a copy job.
  await bigquery
    .dataset(datasetId)
    .table(snapshotTableId)
    .copy(bigquery.dataset(datasetId).table(recoveredTableId));

  console.log(
    `Copied data from deleted table ${tableId} to ${recoveredTableId}`
  );
}

Python

Ver no GitHub Feedback

import time

from google.cloud import bigquery

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

# TODO(developer): Choose a table to recover.
# table_id = "your-project.your_dataset.your_table"

# TODO(developer): Choose a new table ID for the recovered table data.
# recovery_table_id = "your-project.your_dataset.your_table_recovered"

# TODO(developer): Choose an appropriate snapshot point as epoch
# milliseconds. For this example, we choose the current time as we're about
# to delete the table immediately afterwards.
snapshot_epoch = int(time.time() * 1000)

# ...

# "Accidentally" delete the table.
client.delete_table(table_id)  # Make an API request.

# Construct the restore-from table ID using a snapshot decorator.
snapshot_table_id = "{}@{}".format(table_id, snapshot_epoch)

# Construct and run a copy job.
job = client.copy_table(
    snapshot_table_id,
    recovered_table_id,
    # Must match the source and destination tables location.
    location="US",
)  # Make an API request.

job.result()  # Wait for the job to complete.

print(
    "Copied data from deleted table {} to {}".format(table_id, recovered_table_id)
)

A seguir

Para mais informações sobre criação e uso de tabelas, consulte Como criar e usar tabelas.
Para mais informações sobre o gerenciamento de dados, consulte Como trabalhar com dados de tabela.
Para mais informações sobre como especificar esquemas de tabela, consulte Como especificar um esquema.
Para mais informações sobre modificação de esquemas de tabelas, consulte Como modificar esquemas de tabelas.
Para mais informações sobre conjuntos de dados, consulte Introdução aos conjuntos de dados.
Para mais informações sobre visualizações, consulte Introdução às visualizações.