Gerenciar tabelas

Neste documento, você aprende a gerenciar tabelas no BigQuery das seguintes maneiras:

Atualizar as propriedades da tabela:
Renomear (copiar) uma tabela
Copiar uma tabela
Excluir uma tabela
Restaurar uma tabela excluída

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

Antes de começar

Atribua papéis do Identity and Access Management (IAM) que concedam aos usuários as permissões necessárias para realizar cada tarefa deste documento. As permissões necessárias para executar uma tarefa (se houver) são listadas na seção "Permissões necessárias".

Atualizar propriedades da tabela

É possível atualizar os seguintes elementos de uma tabela:

Permissões necessárias

Para receber as permissões necessárias para atualizar as properties da tabela, peça ao administrador que conceda a você o papel do IAM Editor de dados (roles/bigquery.dataEditor) em uma tabela. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para atualizar as properties da tabela. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para atualizar as properties da tabela:

bigquery.tables.update
bigquery.tables.get

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Além disso, se você tiver a permissão bigquery.datasets.create, poderá atualizar as propriedades das tabelas dos conjuntos de dados que criou.

Atualizar a descrição de uma tabela

É possível atualizar a descrição de um conjunto de dados das seguintes maneiras:

Usando o Console do Google Cloud.
usando uma instrução ALTER TABLE de linguagem de definição de dados (DDL);
usando o comando bq update da ferramenta de linha de comando bq;
chamando o método de API tables.patch;
Como usar bibliotecas de cliente.

Para atualizar a descrição de uma tabela:

Console

Não é possível adicionar uma descrição ao criar uma tabela pelo console do Google Cloud. No entanto, depois de criá-la, é possível adicionar a descrição na página Detalhes.

No painel Explorer, expanda o projeto e o conjunto de dados e selecione a tabela.
No painel de detalhes, 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.

SQL

Use a instrução ALTER TABLE SET OPTIONS. O exemplo a seguir atualiza a descrição de uma tabela chamada mytable:

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

Ir para o BigQuery

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

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

Clique em Executar.

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

bq

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

Para alterar a descrição da tabela mytable no conjunto de dados mydataset para "Descrição do mytable", insira o comando a seguir. O conjunto de dados mydataset está no projeto padrão.
```
bq update --description "Description of mytable" mydataset.mytable
```
Para alterar a descrição da tabela mytable no conjunto de dados mydataset para "Descrição do mytable", insira o comando a seguir. O conjunto de dados mydataset está no projeto 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 esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

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

import (
	"context"
	"fmt"

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

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

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

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

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

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

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

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 é criada. Muitas vezes, ele é mencionado como "tempo de vida" ou TTL, na sigla em inglês.

Quando uma tabela expira, ela é excluída com todos os dados que ela contém. Se necessário, é possível cancelar a exclusão da tabela expirada dentro do período de tempo especificado para o conjunto de dados. Consulte Restaurar tabelas excluídas para mais informações.

Se você fizer isso durante a criação da tabela, a expiração 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 vai expirar, e você precisará excluí-la manualmente.

A qualquer momento após a criação da tabela, é possível atualizar o prazo de validade dela das seguintes maneiras:

Usando o Console do Google Cloud.
usando uma instrução ALTER TABLE de linguagem de definição de dados (DDL);
usando o comando bq update da ferramenta de linha de comando bq;
chamando o método de API tables.patch;
Como usar bibliotecas de cliente.

Para atualizar o prazo de validade de uma tabela:

Console

Não é possível adicionar um prazo de validade ao criar uma tabela pelo console do Google Cloud. No entanto, depois de criá-la, é possível adicionar ou atualizar a validade da tabela na página Detalhes da tabela.

No painel Explorer, expanda o projeto e o conjunto de dados e selecione a tabela.
No painel de detalhes, 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.

SQL

Use a instrução ALTER TABLE SET OPTIONS. O exemplo a seguir atualiza o prazo de validade de uma tabela chamada mytable:

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

Ir para o BigQuery

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

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.

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

bq

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

Para atualizar o prazo de validade da tabela mytable no conjunto de dados mydataset para cinco dias (432.000 segundos), insira o seguinte comando: O conjunto de dados mydataset está no projeto padrão.
```
bq update --expiration 432000 mydataset.mytable
```
Para atualizar o prazo de validade da tabela mytable no conjunto de dados mydataset para cinco dias (432.000 segundos), insira o seguinte comando: O conjunto de dados mydataset está no projeto 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

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

import (
	"context"
	"fmt"
	"time"

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

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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import 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());
    }
  }
}

Node.js

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

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

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

async function updateTableExpiration() {
  // Updates a table's expiration.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset', // Existing dataset
  // const tableId = 'my_table', // Existing table
  // const expirationTime = Date.now() + 1000 * 60 * 60 * 24 * 5 // 5 days from current time in ms

  // Retreive current table metadata
  const table = bigquery.dataset(datasetId).table(tableId);
  const [metadata] = await table.getMetadata();

  // Set new table expiration to 5 days from current time
  metadata.expirationTime = expirationTime.toString();
  const [apiResponse] = await table.setMetadata(metadata);

  const newExpirationTime = apiResponse.expirationTime;
  console.log(`${tableId} expiration: ${newExpirationTime}`);
}

Python

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

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

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import datetime


def update_table_expiration(table_id, expiration):
    orig_table_id = table_id
    orig_expiration = expiration

    from google.cloud import bigquery

    client = bigquery.Client()

    # TODO(dev): Change table_id to the full name of the table you want to update.
    table_id = "your-project.your_dataset.your_table_name"

    # TODO(dev): Set table to expire for desired days days from now.
    expiration = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(
        days=5
    )

    table_id = orig_table_id
    expiration = orig_expiration

    table = client.get_table(table_id)  # Make an API request.
    table.expires = expiration
    table = client.update_table(table, ["expires"])  # API request

    print(f"Updated {table_id}, expires {table.expires}.")

Para atualizar o prazo de validade padrão da partição do conjunto de dados:

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.concurrent.TimeUnit;

// Sample to update partition expiration on a dataset.
public class UpdateDatasetPartitionExpiration {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    // Set the default partition expiration (applies to new tables, only) in
    // milliseconds. This example sets the default expiration to 90 days.
    Long newExpiration = TimeUnit.MILLISECONDS.convert(90, TimeUnit.DAYS);
    updateDatasetPartitionExpiration(datasetName, newExpiration);
  }

  public static void updateDatasetPartitionExpiration(String datasetName, 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();

      Dataset dataset = bigquery.getDataset(datasetName);
      bigquery.update(dataset.toBuilder().setDefaultPartitionExpirationMs(newExpiration).build());
      System.out.println(
          "Dataset default partition expiration updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Dataset partition expiration was not updated \n" + e.toString());
    }
  }
}

Python

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

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


def update_dataset_default_partition_expiration(dataset_id: str) -> None:

    from google.cloud import bigquery

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

    # TODO(developer): Set dataset_id to the ID of the dataset to fetch.
    # dataset_id = 'your-project.your_dataset'

    dataset = client.get_dataset(dataset_id)  # Make an API request.

    # Set the default partition expiration (applies to new tables, only) in
    # milliseconds. This example sets the default expiration to 90 days.
    dataset.default_partition_expiration_ms = 90 * 24 * 60 * 60 * 1000

    dataset = client.update_dataset(
        dataset, ["default_partition_expiration_ms"]
    )  # Make an API request.

    print(
        "Updated dataset {}.{} with new default partition expiration {}".format(
            dataset.project, dataset.dataset_id, dataset.default_partition_expiration_ms
        )
    )

Atualizar o modo de arredondamento de uma tabela

É possível atualizar o modo de arredondamento padrão de uma tabela usando a instrução DDL ALTER TABLE SET OPTIONS. O exemplo a seguir atualiza o modo de arredondamento padrão de mytable para ROUND_HALF_EVEN:

ALTER TABLE mydataset.mytable
SET OPTIONS (
  default_rounding_mode = "ROUND_HALF_EVEN");

Quando você adiciona um campo NUMERIC ou BIGNUMERIC a uma tabela e não especifica um modo de arredondamento, esse modo é definido automaticamente como o arredondamento padrão da tabela. Alterar o modo de arredondamento padrão de uma tabela não altera o modo de arredondamento dos campos que já existem.

Atualizar a definição de esquema de uma tabela

Para mais informações sobre como atualizar a definição de esquema de uma tabela, consulte Como modificar esquemas de tabelas.

Renomear uma tabela

É possível renomear uma tabela depois que ela é criada usando a instrução ALTER TABLE RENAME TO. O exemplo a seguir renomeia mytable como mynewtable:

ALTER TABLE mydataset.mytable
RENAME TO mynewtable;

Limitações ao renomear tabelas

Se você quiser renomear uma tabela que tenha streaming de dados, pare o streaming e aguarde o BigQuery indicar que ele não está em uso.
Geralmente, a tabela pode ser renomeada em até 72 horas após a última operação de streaming, mas pode demorar mais.
As ACLs de tabela e as políticas de acesso de linha atuais são preservadas, mas as atualizações da ACL e da política de acesso de linha da tabela feitas durante a renomeação da tabela não são.
Não é possível renomear uma tabela simultaneamente e executar uma instrução DML nela.
Renomear uma tabela remove todas as tags do Data Catalog nela.
Não é possível renomear tabelas externas.

Copiar uma tabela

Nesta seção, você verá como criar uma cópia completa de uma tabela. Para informações sobre outros tipos de cópias de tabela, consulte clones de tabela e snapshots de tabela.

É possível copiar uma tabela das seguintes maneiras:

Use o console do Google Cloud.
Use o comando bq cp.
use uma instrução CREATE TABLE COPY de linguagem de definição de dados (DDL);
chame o método da API jobs.insert e configure um job copy;
use as bibliotecas-cliente.

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 aos limites do BigQuery nos jobs de cópia.
O console do Google Cloud permite copiar apenas uma tabela por vez. Não é possível substituir uma tabela que já existe no conjunto de dados de destino. A tabela precisa ter um nome exclusivo nesse conjunto.
A cópia de várias tabelas de origem em uma tabela de destino não é compatível com o Console do Google Cloud.
Ao copiar várias tabelas de origem para uma tabela de destino usando a API, a ferramenta de linha de comando bq ou as bibliotecas de cliente, todas as tabelas de origem precisam ter esquemas idênticos, incluindo particionamento ou clustering.

Algumas atualizações de esquema de tabela, como descarte ou renomeação de colunas, podem fazer com que as tabelas tenham esquemas aparentemente idênticos, mas representações internas diferentes. Isso pode fazer com que um job de cópia de tabela falhe com o erro Maximum limit on diverging physical schemas reached. Nesse caso, é possível usar a instrução CREATE TABLE LIKE para garantir que o esquema da tabela de origem corresponda exatamente ao esquema da tabela de destino.
O tempo que o BigQuery leva para copiar tabelas pode variar bastante em diferentes execuções porque o armazenamento subjacente é gerenciado de forma dinâmica.
Não é possível copiar e anexar uma tabela de origem a uma tabela de destino que tenha mais colunas do que a tabela de origem, e as colunas adicionais têm valores padrão. Mas é possível executar INSERT destination_table SELECT * FROM source_table para copiar os dados.
Se a operação de cópia substituir uma tabela já existente, o acesso no nível dessa tabela será mantido. As Tags da tabela de origem não são copiadas para a tabela substituída.
Se a operação de cópia criar uma nova tabela, o acesso no nível dessa tabela será determinado pelas políticas de acesso do conjunto de dados em que a nova tabela foi criada. Além disso, as tags são copiadas da tabela de origem para a nova.
Quando você copia várias tabelas de origem para uma tabela de destino, todas elas precisam ter tags idênticas.

Funções exigidas

Para executar as tarefas neste documento, você precisa das seguintes permissões.

Papéis para copiar tabelas e partições

Para receber as permissões necessárias para copiar tabelas e partições, ao administrador que conceda a você o papel do IAM Editor de dados (roles/bigquery.dataEditor) nos conjuntos de dados de origem e destino. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para copiar tabelas e partições. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para copiar tabelas e partições:

bigquery.tables.getData nos conjuntos de dados de origem e destino
bigquery.tables.get nos conjuntos de dados de origem e destino
bigquery.tables.create no conjunto de dados de destino
bigquery.tables.update no conjunto de dados de destino

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Permissão para executar um job de cópia

Para receber a permissão necessária para executar um job de cópia, peça ao administrador que conceda a você o papel do IAM Usuário de jobs (roles/bigquery.jobUser) nos conjuntos de dados de origem e destino. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém a permissão bigquery.jobs.create, que é necessária para executar um job de cópia.

Também é possível conseguir essa permissão com papéis personalizados ou outros papéis predefinidos.

Copiar uma tabela de origem única

É possível copiar uma única tabela das seguintes maneiras:

Usando o Console do Google Cloud.
usando o comando bq cp da ferramenta de linha de comando bq;
usando uma instrução CREATE TABLE COPY de linguagem de definição de dados (DDL);
Fazendo uma chamada do método de API jobs.insert, configurando um job copy e especificando a propriedade sourceTable.
usando bibliotecas de cliente.

O Console do Google Cloud e a instrução CREATE TABLE COPY suportam 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

No painel Explorer, expanda o projeto e o conjunto de dados e selecione a tabela.
No painel de detalhes, 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. Não é possível substituir uma tabela que já existe no conjunto de dados de destino usando o console do Google Cloud. Para mais informações sobre os requisitos de nome de tabela, consulte Nomenclatura de tabelas.
Clique em Copiar para iniciar o job de cópia.

SQL

Use a instrução CREATE TABLE COPY para copiar uma tabela chamada table1 para uma nova tabela chamada table1copy:

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

Ir para o BigQuery

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

CREATE TABLE myproject.mydataset.table1copy
COPY myproject.mydataset.table1;

Clique em Executar.

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

bq

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.
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. É possível definir um valor padrão para o local usando o arquivo .bigqueryrc.
- project_id: o ID do projeto.
- dataset: o nome do conjunto de dados 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:

Para copiar a tabela mydataset.mytable para a tabela mydataset2.mytable2, insira o comando a seguir. Os dois conjuntos de dados estão no projeto padrão.
```
bq cp mydataset.mytable mydataset2.mytable2
```
Para copiar a tabela mydataset.mytable e substituir uma tabela de destino com o mesmo nome, digite o comando a seguir. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está no projeto myotherproject. O atalho -f é usado para substituir a tabela de destino sem enviar uma solicitação.
```
bq cp -f \
mydataset.mytable \
myotherproject:myotherdataset.mytable
```
Para copiar a tabela mydataset.mytable e retornar um erro caso o conjunto de dados de destino contenha uma tabela com o mesmo nome, digite o comando a seguir. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está no projeto 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
```
Para copiar a tabela mydataset.mytable e anexar os dados a uma tabela de destino com o mesmo nome, digite o comando a seguir. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está no projeto 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 esta amostra, siga as instruções de configuração do C# no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em C#.

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


using Google.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.
            .ThrowOnAnyError();

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

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

import (
	"context"
	"fmt"

	"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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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

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

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

async function 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 do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em PHP.

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

use Google\Cloud\BigQuery\BigQueryClient;
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

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


from google.cloud import bigquery

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

# TODO(developer): Set 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.")

Copiar várias tabelas de origem

É possível copiar várias tabelas de origem em uma tabela de destino das seguintes maneiras:

usando 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 bibliotecas de cliente.

Todas as tabelas de origem precisam ter esquemas e tags idênticos, e 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 curinga ao copiar várias tabelas de origem.

Para copiar várias tabelas de origem, selecione uma das seguintes opções:

bq

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.
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. É possível definir um valor padrão para o local usando o arquivo .bigqueryrc.
- project_id: o ID do projeto.
- dataset: o nome do conjunto de dados 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:

Para copiar as tabelas mydataset.mytable, mydataset.mytable2 e mydataset2.tablecopy, digite o seguinte comando: Todos os conjuntos de dados estão no projeto padrão.
```
bq cp \
mydataset.mytable,mydataset.mytable2 \
mydataset2.tablecopy
```
Para copiar a tabela mydataset.mytable e a tabela mydataset.mytable2 para a tabela myotherdataset.mytable e para substituir uma tabela de destino com o mesmo nome, digite o seguinte comando: O conjunto de dados de destino está no projeto myotherproject, 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
```
Para copiar as tabelas 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, digite o comando a seguir. O conjunto de dados de destino está no projeto 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
```
Para copiar as tabelas mydataset.mytable e mydataset.mytable2 e anexar os dados a uma tabela de destino com o mesmo nome, digite o comando a seguir. O conjunto de dados de origem está no projeto padrão. O conjunto de dados de destino está no projeto 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

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

import (
	"context"
	"fmt"

	"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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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

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

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

async function 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

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


from google.cloud import bigquery

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

# TODO(developer): Set 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))

Copiar tabelas entre regiões

É possível copiar uma tabela, um snapshot da tabela ou um clone da tabela de uma região do BigQuery ou de uma multirregião para outra. Isso inclui todas as tabelas em que o Cloud KMS gerenciado pelo cliente (CMEK) é aplicado. Essa ação gera cobranças adicionais de acordo com os preços do BigQuery.

Para copiar uma tabela entre regiões, selecione uma das seguintes opções:

bq

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.
Execute o comando bq cp:

   bq cp \
   -f -n \
   SOURCE_PROJECT:SOURCE_DATASET.SOURCE_TABLE \
   DESTINATION_PROJECT:DESTINATION_DATASET.DESTINATION_TABLE

Substitua:

SOURCE_PROJECT: ID do projeto fonte. Se o conjunto de dados de origem estiver em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados de origem.
DESTINATION_PROJECT: ID do projeto de destino Se o conjunto de dados de destino estiver em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados de destino.
SOURCE_DATASET: o nome do conjunto de dados de origem.
DESTINATION_DATASET: o nome do conjunto de dados de destino.
SOURCE_TABLE: a tabela que você está copiando.
DESTINATION_TABLE: o nome da tabela no conjunto de dados de destino.

Exemplos:

Para copiar a tabela mydataset_us.mytable da multirregião us para a tabela mydataset_eu.mytable2 na multirregião eu, digite o comando a seguir. Os dois conjuntos de dados estão no projeto padrão.
```
bq cp --sync=false mydataset_us.mytable mydataset_eu.mytable2
```
Para copiar uma tabela com CMEK ativado, crie uma chave usando o Cloud KMS e especifique a chave no comando bq cp ou use um conjunto de dados de destino com o CMEK padrão configurado. O exemplo a seguir especifica o CMEK de destino no comando bq cp.
```
bq cp --destination_kms_key=projects/testing/locations/us/keyRings/us_key/cryptoKeys/eu_key mydataset_us.mytable mydataset_eu.mytable2
```

API

Para copiar uma tabela entre regiões usando a API, chame o método jobs.insert e configure um job copy da tabela.

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

C#

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


using Google.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.
            .ThrowOnAnyError();

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

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

import (
	"context"
	"fmt"

	"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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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

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

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

async function 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

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

use Google\Cloud\BigQuery\BigQueryClient;
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

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


from google.cloud import bigquery

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

# TODO(developer): Set 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.")

Limitações

Copiar uma tabela entre regiões está sujeita às seguintes limitações:

Não é possível copiar uma tabela usando o console do Google Cloud ou a instrução TABLE COPY DDL.
Não é possível copiar uma tabela quando há tags de política na tabela de origem.
Não é possível copiar políticas do IAM associadas às tabelas. É possível aplicar as mesmas políticas ao destino depois que a cópia é concluída.
Não é possível copiar várias tabelas de origem em uma única tabela de destino.
Não é possível copiar tabelas no modo de anexação.
As informações de viagem no tempo não são copiadas para a região de destino.
Os clones de tabela são convertidos em uma cópia completa na região de destino.

Conferir o uso atual da cota

É possível conferir seu uso atual de jobs de consulta, carregamento, extração ou cópia executando uma consulta INFORMATION_SCHEMA para visualizar metadados sobre os jobs executados em um período especificado. É possível comparar seu uso atual com o limite de cota para determinar o uso de cota para um tipo específico de job. O exemplo de consulta a seguir usa a visualização INFORMATION_SCHEMA.JOBS para listar o número de jobs de consulta, carregamento, extração e cópia por projeto:

SELECT
  sum(case  when job_type="QUERY" then 1 else 0 end) as QRY_CNT,
  sum(case  when job_type="LOAD" then 1 else 0 end) as LOAD_CNT,
  sum(case  when job_type="EXTRACT" then 1 else 0 end) as EXT_CNT,
  sum(case  when job_type="COPY" then 1 else 0 end) as CPY_CNT
FROM `region-eu`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE date(creation_time)= CURRENT_DATE()

Para conferir os limites de cota dos jobs de cópia, consulte Cotas e limites: jobs de cópia.

Excluir tabelas

É possível excluir um conjunto de dados das seguintes maneiras:

Usando o Console do Google Cloud.
usando uma instrução DROP TABLE de linguagem de definição de dados (DDL);
usando o comando bq rm da ferramenta de linha de comando bq;
chamando o método de API tables.delete;
usando bibliotecas de cliente.

Para excluir todas as tabelas do conjunto de dados, exclua o conjunto de dados.

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.

A exclusão de uma tabela também exclui todas as permissões associadas a ela. Ao recriar uma tabela excluída, você também precisa reconfigurar manualmente as permissões de acesso associadas a ela.

Funções exigidas

Para conseguir as permissões necessárias para excluir uma tabela, peça ao administrador que conceda a você o papel do IAM Editor de dados (roles/bigquery.dataEditor) no conjunto de dados. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para excluir uma tabela. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para excluir uma tabela:

bigquery.tables.delete
bigquery.tables.get

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Excluir uma tabela

Para fazer isso:

Console

No painel Explorer, expanda o projeto e o conjunto de dados e selecione a tabela.
No painel de detalhes, clique em Excluir tabela.
Digite "delete" na caixa de diálogo e clique em Excluir para confirmar.

SQL

Use a instrução DROP TABLE. No exemplo a seguir, uma tabela chamada mytable é excluída:

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

Ir para o BigQuery
No editor de consultas, digite a seguinte instrução:
```
DROP TABLE mydataset.mytable;
```
Clique em Executar.

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

bq

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.
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 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: ID do projeto
- dataset: o nome do conjunto de dados onde está a tabela
- table: o nome da tabela que você está excluindo
Exemplos:

Para excluir a tabela mytable do conjunto de dados mydataset, digite o comando a seguir. O conjunto de dados mydataset está no projeto padrão.
```
bq rm -t mydataset.mytable
```
Para excluir a tabela mytable do conjunto de dados mydataset, digite o comando a seguir. O conjunto de dados mydataset está no projeto myotherproject, e não no projeto padrão.
```
bq rm -t myotherproject:mydataset.mytable
```
Para excluir a tabela mytable do conjunto de dados mydataset, digite o comando a seguir. O conjunto de dados mydataset está no projeto padrão. O comando usa o atalho -f para ignorar a confirmação.
```
bq rm -f -t mydataset.mytable
```
Observação: é possível inserir o comando bq ls dataset na ferramenta de linha de comando bq para confirmar que uma tabela foi removida de um conjunto de dados.

API

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

C#

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


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

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

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

import (
	"context"
	"fmt"

	"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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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

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

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

async function 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

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

use Google\Cloud\BigQuery\BigQueryClient;

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

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

Python

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


from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the table to 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 do Ruby no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Ruby.

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

require "google/cloud/bigquery"

def 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

Restaurar tabelas excluídas

É possível cancelar a exclusão de uma tabela dentro do período de tempo especificado para o conjunto de dados, incluindo exclusões explícitas e implícitas devido à expiração da tabela. Você pode configurar a janela de viagem no tempo. Para cancelar a exclusão de um conjunto de dados inteiro, consulte Cancelar a exclusão de conjuntos de dados.

O período de viagem pode ser de dois a sete dias. Após o período decorrido, não é possível cancelar a exclusão de uma tabela usando qualquer método, incluindo a abertura de um tíquete de suporte.

Ao restaurar uma tabela a partir de dados históricos, as tags da tabela de origem não são copiadas para a tabela de destino.

É possível restaurar uma tabela que foi excluída, mas ainda está dentro do período de viagem copiando-a para uma nova tabela usando o decorador de tempo @<time>. Para copiar a tabela, use a ferramenta de linha de comando bq ou as bibliotecas de cliente:

Console

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

bq

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.
Para restaurar uma tabela, primeiro determine um carimbo de data/hora UNIX de quando a tabela existia (em milissegundos). É possível usar o comando date do Linux para gerar o carimbo de data/hora Unix a partir de um valor de carimbo de data/hora normal:
```
date -d '2023-08-04 16:00:34.456789Z' +%s000
```
Em seguida, use o comando bq copy com o decorador de viagem no tempo @<time> para executar a operação de cópia da tabela.

Por exemplo, digite o seguinte comando para copiar a tabela mydataset.mytable no momento 1418864998000 para uma nova tabela mydataset.newtable.
```
bq cp mydataset.mytable@1418864998000 mydataset.newtable
```
Opcional: forneça a sinalização --location e defina o valor do local.

Também é possível especificar um deslocamento relativo. O exemplo a seguir copia a versão de uma tabela de uma hora atrás:
```
bq cp mydataset.mytable@-3600000 mydataset.newtable
```
Para mais informações, consulte Restaurar uma tabela de um momento.

Go

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

import (
	"context"
	"fmt"
	"time"

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

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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.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

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

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

async function 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

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

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

Se você antecipar que talvez queira restaurar uma tabela mais tarde diferente da permitida pelo período de viagem, crie um snapshot da tabela. Para mais informações, consulte Snapshots de tabelas.

Segurança de tabelas

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

A seguir

Para mais informações sobre como criar e usar tabelas, consulte esta página.
Para saber mais 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 como modificar esquemas de tabelas, consulte esta página.
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.