管理表

本文档介绍了如何管理 BigQuery 中的表。您可以通过以下方式管理 BigQuery 表：

• 更新表的以下内容：
  • 到期时间
  • 说明
  • 架构定义
  • 标签
• 重命名（复制）表
• 复制表
• 删除表
• 恢复已删除的表

如需详细了解如何创建和使用表（包括获取表信息、列出表以及控制对表数据的访问），请参阅创建和使用表。

准备工作

授予为用户提供执行本文档中的每个任务所需权限的 Identity and Access Management (IAM) 角色。 执行任务所需的权限（如果有）列出在任务的“所需权限”部分中。

更新表属性

您可以更新表的以下元素：

• 说明
• 到期时间
• 架构定义
• 标签
• 表名称

所需权限

如需更新表，您需要拥有以下 IAM 权限：

• bigquery.tables.update
• bigquery.tables.get

以下每个预定义的 IAM 角色均包含更新表所需的权限：

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin

此外，如果您拥有 bigquery.datasets.create 权限，则可以更新您创建的数据集的表属性。

如需详细了解 BigQuery 中的 IAM 角色和权限，请参阅预定义的角色和权限。

更新表的说明

您可以通过以下方式更新表的说明：

• 使用 Cloud Console。
• 使用数据定义语言 (DDL) ALTER TABLE 语句。
• 使用 bq 命令行工具的 bq update 命令。
• 调用 tables.patch API 方法。
• 使用客户端库。

若要更新表的说明，请执行以下操作：

控制台

使用 Cloud Console 创建表时，您无法添加说明。创建表后，您可以在详细信息页面上添加说明。

1. 在探索器面板中，展开您的项目和数据集，然后选择表。

2. 在详细信息面板中，点击详细信息。

3. 在说明部分，点击铅笔图标以修改说明。

   

4. 在文本框中输入说明，然后点击更新进行保存。

SQL

借助 DDL 语句，您可以使用标准 SQL 查询语法创建和修改表和视图。

详细了解如何使用数据定义语言语句。

若要在 Cloud Console 中使用 DDL 语句更新表的说明，请执行以下操作：

1. 点击编写新查询。

2. 在查询编辑器文本区域中，输入您的 DDL 语句。

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

3. 点击运行。

bq

发出带 --description 标志的 bq update 命令。如果您要更新非默认项目中的表，请按以下格式将相应项目 ID 添加到数据集名称中：project_id:dataset。

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

替换以下内容：

• description：加英文引号的说明表的文本。
• project_id：您的项目 ID
• dataset：要更新的表所属数据集的名称
• table：要更新的表的名称

示例：

输入以下命令，将 mydataset 中 mytable 的说明更改为“Description of mytable”。mydataset 属于默认项目。

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

输入以下命令，将 mydataset 中 mytable 的说明更改为“Description of mytable”。mydataset 属于 myotherproject，而非默认项目。

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

API

调用 tables.patch 方法并使用表资源中的 description 属性来更新表的说明。由于 tables.update 方法会替换整个表资源，因此最好使用 tables.patch 方法。

Go

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

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

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

配置 Table.description 属性并调用 Client.update_table() 向 API 发送更新。

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

更新表的到期时间

您可以在数据集级层设置默认的表到期时间，也可以在创建表时设置表的到期时间。表的到期时间通常称为“存留时间”或 TTL。

如果在创建表时设置到期时间，则会忽略数据集的默认表到期时间。如果未在数据集级层设置默认的表到期时间，也未在创建表时设置表到期时间，则该表永不过期，您必须手动删除该表。

表创建完毕后，您可以随时通过以下方式更新表的到期时间：

• 使用 Cloud Console。
• 使用数据定义语言 (DDL) ALTER TABLE 语句。
• 使用 bq 命令行工具的 bq update 命令。
• 调用 tables.patch API 方法。
• 使用客户端库。

注意：如果您设置的到期时间为过去的时间，则系统会立即删除表。

如需更新表的到期时间，请执行以下操作：

控制台

使用 Cloud Console 创建表时，您无法添加到期时间。创建表后，您可以在表详细信息页面上添加或更新表过期时间。

1. 在探索器面板中，展开您的项目和数据集，然后选择表。

2. 在详细信息面板中，点击详细信息。

3. 点击表信息旁边的铅笔图标

4. 对于表过期时间，选择指定日期。然后使用下面的日历微件选择到期日期。

5. 点击更新进行保存。已更新的到期时间会显示在表信息部分中。

SQL

借助 DDL 语句，您可以使用标准 SQL 查询语法创建和修改表和视图。

详细了解如何使用数据定义语言语句。

若要在 Cloud Console 中使用 DDL 语句更新到期时间，请执行以下操作：

1. 点击编写新查询。

2. 在查询编辑器文本区域中，输入您的 DDL 语句。

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

3. 点击运行。

bq

发出带 --expiration 标志的 bq update 命令。如果您要更新非默认项目中的表，请按以下格式将相应项目 ID 添加到数据集名称中：project_id:dataset。

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

替换以下内容：

• integer：表的默认生命周期（以秒为单位）。最小值为 3600 秒（一小时）。过期时间以当前时间加上这个整数值为准。如果您指定 0，表过期时间将被移除，且表永不过期。您必须手动删除未设定过期时间的表。
• project_id：您的项目 ID。
• dataset：要更新的表所属数据集的名称。
• table：要更新的表的名称。

示例：

输入以下命令可将 mydataset 中 mytable 的到期时间更新为 5 天（432000 秒）。mydataset 属于默认项目。

bq update --expiration 432000 mydataset.mytable

输入以下命令可将 mydataset 中 mytable 的到期时间更新为 5 天（432000 秒）。mydataset 属于 myotherproject，而非默认项目。

bq update --expiration 432000 myotherproject:mydataset.mytable

API

调用 tables.patch 方法，并使用表资源中的 expirationTime 属性更新表过期时间（以毫秒为单位）。由于 tables.update 方法会替换整个表资源，因此最好使用 tables.patch 方法。

Go

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

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

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

配置 Table.expires 属性并调用 Client.update_table() 向 API 发送更新。

在 GitHub 上查看 反馈

import datetime

# 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(datetime.timezone.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

如需更新默认数据集分区到期时间，请执行以下操作：

Java

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

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

更新表的架构定义

如需详细了解如何更新表的架构定义，请参阅修改表架构。

重命名表

您可以在创建表后使用 ALTER TABLE RENAME TO 数据定义语言 (DDL) 语句重命名表。

SQL

借助 DDL 语句，您可以使用标准 SQL 查询语法创建和修改表和视图。

详细了解如何使用数据定义语言语句。

如需在 Cloud Console 中使用 DDL 语句更新表的名称，请执行以下操作：

1. 点击编写新查询。

2. 在查询编辑器文本区域中，输入您的 DDL 语句。

    ALTER TABLE mydataset.mytable
    RENAME TO mynewtable
    

3. 点击运行。

复制表

您可以通过以下方式复制表：

• 使用 Cloud Console。
• 使用 bq 命令行工具的 bq cp 命令。
• 调用 jobs.insert API 方法并配置 copy 作业
• 使用客户端库。

复制表的限制

表的复制作业受到以下限制：

• 复制表时，目标表的名称必须遵循与创建表时相同的命名惯例。
• 表的副本需遵循 BigQuery 对复制作业的限制。
• 使用 Cloud Console 复制表时，不能覆盖目标数据集中的现有表。该表必须在目标数据集中具有唯一名称。
• 复制表时，目标数据集与要复制的表所属的源数据集必须位于同一位置。例如，您无法从欧盟的数据集复制表并将其写入美国境内的数据集。
• Cloud Console 不支持将多个源表复制到目标表。
• 使用 API 或 bq 命令行工具将多个源表复制到目标表时，所有源表的架构必须相同。
• 由于底层存储是动态管理的，因此 BigQuery 复制表所花费的时间可能因不同的运行而异。

所需权限

如需执行本文档中的任务，您需要以下权限。

复制表和分区的权限

如需复制表和分区，您需要拥有源数据集和目标数据集的 IAM 权限。

• 在源数据集上，您需要以下权限：

  • bigquery.tables.get
  • bigquery.tables.getData

• 在目标数据集上，您需要以下权限：

  • bigquery.tables.create：此权限允许您在目标数据集中创建表或分区的副本。

以下预定义的每个 IAM 角色均包含复制表和分区所需的权限：

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin

运行复制作业的权限

如需运行复制作业，您需要 bigquery.jobs.create IAM 权限。

以下预定义的每个 IAM 角色均包含运行复制作业所需的权限：

• roles/bigquery.user
• roles/bigquery.jobUser
• roles/bigquery.admin

此外，如果您拥有 bigquery.datasets.create 权限，则可以复制您创建的数据集中的表和分区。您还需要目标数据集的访问权限。

如需详细了解 BigQuery 中的 IAM 角色和权限，请参阅预定义的角色和权限。

复制单个源表

您可以通过以下方式复制单个表：

• 使用 Cloud Console。
• 使用 bq 命令行工具的 bq cp 命令。
• 调用 jobs.insert API 方法，配置一个 copy 作业并指定 sourceTable 属性。
• 使用客户端库。

在一个复制作业中，Cloud Console 仅支持一个源表和一个目标表。如需将多个源文件复制到目标表，必须使用 bq 命令行工具或 API。

如需复制单个源表，请执行以下操作：

控制台

1. 在探索器面板中，展开您的项目和数据集，然后选择表。

2. 在详细信息面板中，点击复制表。

3. 在复制表对话框的目标下：

   • 在项目名称部分，选择将存储复制表的项目。
   • 在数据集名称部分，选择要存储复制表的数据集。源数据集和目标数据集必须在同一位置。
   • 在表名部分，输入新表的名称。该名称在目标数据集中必须唯一。您无法使用 Cloud Console 覆盖目标数据集中的现有表。如需详细了解表名要求，请参阅表命名。

4. 点击复制以开始复制作业。

bq

发出 bq cp 命令。可使用以下可选标志控制目标表的写入处置方式：

• -a 或 --append_table 用于将源表中的数据附加到目标数据集中的现有表。
• -f 或 --force 会覆盖目标数据集中的现有表，并且不会提示您进行确认。
• -n 或 --no_clobber 会在目标数据集中已存在同名表时返回以下错误消息：Table 'project_id:dataset.table' already exists, skipping.。如果未指定 -n，则默认行为是提示您选择是否替换目标表。
• --destination_kms_key 是客户管理的 Cloud KMS 密钥，用于加密目标表。

本文未演示 --destination_kms_key。如需了解详情，请参阅使用 Cloud Key Management Service 密钥保护数据。

如果源数据集或目标数据集属于非默认项目，请按以下格式将相应项目 ID 添加到数据集名称中：project_id:dataset。

（可选）提供 --location 标志并将其值设置为您的位置。

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

请替换以下内容：

• location：您所在位置的名称。--location 是可选标志。例如，如果您在东京区域使用 BigQuery，可将该标志的值设置为 asia-northeast1。您可以使用 .bigqueryrc 文件设置默认位置值。
• project_id：您的项目 ID。
• dataset：源数据集或目标数据集的名称。
• source_table：要复制的表。
• destination_table：目标数据集中表的名称。

示例：

输入以下命令可将 mydataset.mytable 复制到 mydataset2.mytable2。两个数据集均属于默认项目。

bq cp mydataset.mytable mydataset2.mytable2

输入以下命令可复制 mydataset.mytable 并覆盖具有相同名称的目标表。源数据集属于默认项目。目标数据集属于 myotherproject。-f 快捷键用于在无提示的情况下覆盖目标表。

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

输入以下命令可复制 mydataset.mytable 并会在目标数据集中包含同名表时返回错误。源数据集属于默认项目。目标数据集属于 myotherproject。-n 快捷键用于防止覆盖具有相同名称的表。

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

输入以下命令可复制 mydataset.mytable 并向具有相同名称的目标表附加数据。源数据集属于默认项目。目标数据集属于 myotherproject。- a 快捷键用于附加到目标表。

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

API

若要通过 API 复制现有的表，您可以调用 bigquery.jobs.insert 方法并配置一个 copy 作业。在作业资源的 jobReference 部分的 location 属性中指定您的位置。

您必须在作业配置中指定以下值：

"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
    },

其中，sourceTable 提供要复制的表的相关信息，destinationTable 提供新表的相关信息，createDisposition 指定是否在表不存在时创建表，writeDisposition 指定是覆盖还是附加到现有的表。

C#

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 C# 设置说明进行操作。如需了解详情，请参阅 BigQuery C# API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

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

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 PHP 设置说明进行操作。如需了解详情，请参阅 BigQuery PHP API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

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

复制多个源表

您可以通过以下方式将多个源表复制到目标表：

• 使用 bq 命令行工具的 bq cp 命令。
• 调用 jobs.insert 方法，配置一个 copy 作业并指定 sourceTables 属性。
• 使用客户端库。

所有源表必须具有相同架构，并且只能有一个目标表。

在指定源表时，您必须采用以英文逗号分隔的列表的形式。在复制多个源表时，您不能使用通配符。

如需复制多个源表，请执行以下操作：

控制台

目前，Cloud Console 不支持复制多个表。

bq

发出 bq cp 命令并采用英文逗号分隔列表的形式添加多个源表。可使用以下可选标志控制目标表的写入处置方式：

• -a 或 --append_table 用于将源表中的数据附加到目标数据集中的现有表。
• -f 或 --force 用于覆盖目标数据集中的现有目标表，并且不会提示您进行确认。
• -n 或 --no_clobber 会在目标数据集中已存在同名表时返回以下错误消息：Table 'project_id:dataset.table' already exists, skipping.。如果未指定 -n，则默认行为是提示您选择是否替换目标表。
• --destination_kms_key是客户管理的 Cloud Key Management Service 密钥，用于加密目标表。

本文未演示 --destination_kms_key。如需了解详情，请参阅使用 Cloud Key Management Service 密钥保护数据。

如果源数据集或目标数据集属于非默认项目，请按以下格式将相应项目 ID 添加到数据集名称中：project_id:dataset。

（可选）提供 --location 标志并将其值设置为您的位置。

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

请替换以下内容：

• location：您所在位置的名称。--location 是可选标志。例如，如果您在东京区域使用 BigQuery，可将该标志的值设置为 asia-northeast1。您可以使用 .bigqueryrc 文件设置默认位置值。
• project_id：您的项目 ID。
• dataset：源数据集或目标数据集的名称。
• source_table：要复制的表。
• destination_table：目标数据集中表的名称。

示例：

输入以下命令可将 mydataset.mytable 和 mydataset.mytable2 复制到 mydataset2.tablecopy。所有数据集均属于默认项目。

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

输入以下命令可将 mydataset.mytable 和 mydataset.mytable2 复制到 myotherdataset.mytable 并覆盖具有相同名称的目标表。目标数据集属于 myotherproject，而非默认项目。-f 快捷键用于在无提示的情况下覆盖目标表。

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

输入以下命令可复制 myproject:mydataset.mytable 和 myproject:mydataset.mytable2 并会在目标数据集中包含同名表时返回错误。目标数据集属于 myotherproject。-n 快捷键用于防止覆盖具有相同名称的表。

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

输入以下命令可复制 mydataset.mytable 和 mydataset.mytable2 并向具有相同名称的目标表附加数据。源数据集属于默认项目。目标数据集属于 myotherproject。-a 快捷键用于附加到目标表。

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

API

如需使用 API 复制多个表，请调用 jobs.insert 方法，配置一个表 copy 作业，并指定 sourceTables 属性。

在作业资源的 jobReference 部分的 location 属性中指定您的区域。

Go

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

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

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

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

删除表

您可以通过以下方式删除表：

• 使用 Cloud Console。
• 使用数据定义语言 (DDL) DROP TABLE 语句。
• 使用 bq 命令行工具的 bq rm 命令。
• 调用 tables.delete API 方法。
• 使用客户端库。

目前，您每次只能删除一个表。

删除表时，该表中的所有数据也将一并删除。若要在指定的时间段后自动删除表，请设置数据集的默认表过期时间，或在创建表时设置到期时间。

所需权限

如需删除表，您需要拥有以下 IAM 权限：

• bigquery.tables.delete
• bigquery.tables.get

以下每个预定义的 IAM 角色均包含删除表所需的权限：

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin

此外，如果您拥有 bigquery.datasets.create 权限，则可以删除自己创建的数据集的表。

如需详细了解 BigQuery 中的 IAM 角色和权限，请参阅预定义的角色和权限。

删除表

如需删除表，请执行以下操作：

控制台

1. 在探索器面板中，展开您的项目和数据集，然后选择表。

2. 在详细信息面板中，点击删除表。

3. 在对话框中输入 "delete"，然后点击删除进行确认。

SQL

借助 DDL 语句，您可以使用标准 SQL 查询语法删除表。

详细了解如何使用数据定义语言语句。

如需在 Cloud Console 中使用 DDL 语句删除现有表，请按照以下步骤操作：

1. 点击编写新查询。

2. 在查询编辑器字段中，输入 DDL 语句。

    DROP TABLE mydataset.mytable
    

3. 点击运行。

bq

使用带有 --table 标志（或 -t 快捷方式）的 bq rm 命令删除表。使用 bq 命令行工具移除表时，必须确认该操作。您可以使用 --force 标志（或 -f 快捷方式）跳过确认。

如果该表属于非默认项目中的数据集，请按以下格式将相应项目 ID 添加到数据集名称中：project_id:dataset。

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

替换以下内容：

• project_id：您的项目 ID
• dataset：包含该表的数据集的名称
• table：要删除的表的名称

示例：

输入以下命令可从 mydataset 删除 mytable。mydataset 属于默认项目。

bq rm -t mydataset.mytable

输入以下命令可从 mydataset 删除 mytable。mydataset 属于 myotherproject，而非默认项目。

bq rm -t myotherproject:mydataset.mytable

输入以下命令可从 mydataset 删除 mytable。mydataset 属于默认项目。该命令使用 -f 快捷方式绕过确认。

bq rm -f -t mydataset.mytable

注意：您可以在 bq 命令行工具中输入 bq ls dataset 命令来确认表是否已从数据集中移除。

API

调用 tables.delete API 方法并使用 tableId 参数指定要删除的表。

C#

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 C# 设置说明进行操作。如需了解详情，请参阅 BigQuery C# API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

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

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 PHP 设置说明进行操作。如需了解详情，请参阅 BigQuery PHP API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Ruby 设置说明进行操作。如需了解详情，请参阅 BigQuery Ruby API 参考文档。

在 GitHub 上查看 反馈

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

恢复已删除的表

表删除后的 7 天内，您可以恢复删除的表，包括显式删除和因表过期的隐式删除。7 天后，您将无法通过任何方法（包括打开支持服务工单）恢复删除的表。

恢复因过期而被删除的分区表时，您必须手动重新创建分区。

通过使用 @<time> 时间修饰器将表复制到新表，您可以恢复最近 7 天内删除的表。您可以使用 bq 命令行工具或客户端库复制表：

控制台

您无法使用 Cloud Console 恢复删除的表。

bq

如需恢复表，请将表复制操作与 @<time> 快照修饰器一起使用。首先，确定表存在时间的 UNIX 时间戳（以毫秒为单位）。然后，使用 bq copy 命令和快照修饰器。

例如，输入以下命令可将时间为 1418864998000 的 mydataset.mytable 复制到新表 mydataset.newtable。

bq cp mydataset.mytable@1418864998000 mydataset.newtable

（可选）提供 --location 标志并将其值设置为您的位置。

您还可以指定相对偏移量。以下示例复制一小时前表的版本：

bq cp mydataset.mytable@-3600000 mydataset.newtable

如需了解详情，请参阅从某个时间点恢复表。

Go

在 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

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

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

尝试此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

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

如果您预期要在表删除或过期的 7 天之后恢复表，请创建表的表快照。如需了解详情，请参阅表快照。

表安全性

如需控制对 BigQuery 中表的访问权限，请参阅表访问权限控制简介。

后续步骤

• 如需详细了解如何创建和使用表，请参阅创建和使用表。
• 如需详细了解如何处理数据，请参阅处理表数据。
• 如需详细了解如何指定表架构，请参阅指定架构。
• 如需详细了解如何修改表架构，请参阅修改表架构。
• 如需详细了解数据集，请参阅数据集简介。
• 如需详细了解视图，请参阅视图简介。