管理表

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

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

如需详细了解如何创建和使用表,包括获取表信息、列出表和控制对表数据的访问权限,请参阅创建和使用表

更新表属性

您可以更新表的以下内容:

所需权限

如需更新表,您至少必须具有 bigquery.tables.updatebigquery.tables.get 权限。以下预定义 IAM 角色具有 bigquery.tables.updatebigquery.tables.get 权限:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

此外,如果用户具有 bigquery.datasets.create 权限,则当该用户创建数据集时,系统会为其授予该数据集的 bigquery.dataOwner 访问权限。具备 bigquery.dataOwner 访问权限的用户有权更新其创建的数据集中的表属性。

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

更新表的说明

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

  • 使用 Cloud Console 或经典版 BigQuery 网页界面
  • 使用 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. 点击运行

经典版界面

  1. 在导航窗格中,选择表。

  2. Table Details 页面上,点击 Details

  3. Description 部分,点击 Describe this table 以打开说明框。

  4. 在该框中输入说明。点击说明框以外的位置即可保存文本。

    表说明。

bq

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

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

替换以下内容:

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

示例:

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

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

输入以下命令,将 mydatasetmytable 的说明更改为“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 参考文档

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 参考文档

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 发送更新。

# 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 或经典版 BigQuery 网页界面
  • 使用 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. 点击运行

经典版界面

  1. 在导航窗格中,选择表。

  2. Table Details 页面上,点击 Details

  3. 对于 Expiration Time,点击 Edit

  4. Update Expiration 对话框中,点击 In,再输入以天为单位的到期时间。

  5. 点击 OK。已更新的过期时间会显示在 Details 页面上。

    表过期时间。

bq

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

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

替换以下内容:

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

示例:

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

bq update --expiration 432000 mydataset.mytable

输入以下命令可将 mydatasetmytable 的到期时间更新为 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 参考文档

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 参考文档

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

public class UpdateTableExpiration {

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

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

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

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

Python

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

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

import datetime
import pytz

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

assert table.expires is None

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

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

更新表的架构定义

如需了解更新表的架构定义的说明,请参阅修改表架构

重命名表

当前无法更改现有表的名称。如果需要更改表名称,请按照复制表的步骤进行操作。在复制操作中指定目标表时,请使用新的表名称。

复制表

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

  • 使用 Cloud Console 或经典版 BigQuery 网页界面
  • 使用 bq 命令行工具的 bq cp 命令
  • 调用 jobs.insert API 方法并配置 copy 作业
  • 使用客户端库

所需权限

若要复制表和分区,您必须至少具有以下权限。

对于源数据集

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

对于目标数据集

  • bigquery.tables.create:用于在目标数据集中创建表或分区的副本

以下预定义的 IAM 角色具有 bigquery.tables.createbigquery.tables.getbigquery.tables.getData 权限:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

此外,若要运行复制作业,您必须具有 bigquery.jobs.create 权限。

以下预定义的 IAM 角色具有 bigquery.jobs.create 权限:

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

此外,如果用户具有 bigquery.datasets.create 权限,则当该用户创建数据集时,系统会为其授予该数据集的 bigquery.dataOwner 访问权限。具备 bigquery.dataOwner 访问权限的用户可以复制该数据集中的表和分区,但如果目标数据集并非由该用户创建,则用户还需要具备对目标数据集的访问权限。

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

复制表的限制

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

  • 复制表时,目标表的名称必须遵循与创建表时相同的命名惯例。
  • 表的副本需遵循 BigQuery 的有关复制作业的配额政策
  • 使用 Cloud Console 或经典版 BigQuery 网页界面复制表时,不能覆盖目标数据集中的现有表。该表必须在目标数据集中具有唯一名称。
  • 复制表时,目标数据集与要复制的表所属的源数据集必须位于同一位置。例如,您无法从欧盟的数据集复制表并将其写入美国境内的数据集。
  • Cloud Console 或经典版 BigQuery 网页界面不支持将多个源表复制到目标表。
  • 使用 API 或 bq 命令行工具将多个源表复制到目标表时,所有源表的架构必须相同。

复制单个源表

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

  • 使用 Cloud Console 或经典版 BigQuery 网页界面
  • 使用 bq 命令行工具的 bq cp 命令
  • 调用 jobs.insert API 方法,配置一个 copy 作业并指定 sourceTable 属性
  • 使用客户端库

在 Cloud Console 和经典版 BigQuery 网页界面,仅支持一个复制作业中有一个源表和一个目标表。如需将多个源文件复制到目标表,必须使用 bq 命令行工具或 API。

如需复制单个源表,请执行以下操作:

控制台

  1. 资源窗格中选择要复制的表。

  2. 查询编辑器下方,点击复制表

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

    • 项目名称部分,选择将存储复制表的项目。
    • 数据集名称部分,选择要存储复制表的数据集。源数据集和目标数据集必须在同一位置
    • 表名部分,输入新表的名称。该名称在目标数据集中必须唯一。表名称不得超过 1024 个字符,并且只能包含 a-z、A-Z、0-9 或 _(下划线字符)。您无法使用 Cloud Console 覆盖目标数据集中的现有表。
  4. 点击复制以开始复制作业。

经典版界面

  1. 点击要复制的表旁边的 向下箭头 显示菜单图标,然后点击 Copy Table

  2. Copy Table 对话框中执行以下操作:

    • 对于 Destination project,选择将存储复制表的项目。
    • 对于 Destination dataset,选择要存储复制表的数据集。源数据集和目标数据集必须在同一位置
    • 对于 Destination table,输入新表的名称。该名称在目标数据集中必须唯一。表名称不得超过 1024 个字符,并且只能包含 a-z、A-Z、0-9 或 _(下划线字符)。您不能使用经典版 BigQuery 网页界面覆盖目标数据集中的现有表。

      表复制。

  3. 点击 OK 启动复制作业。

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 参考文档


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 参考文档

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 参考文档

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 参考文档

// 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 参考文档

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 参考文档


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 不支持复制多个表。

经典版界面

目前,经典版 BigQuery 网页界面不支持复制多个表。

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.mytablemydataset.mytable2 复制到 mydataset2.tablecopy。所有数据集均属于默认项目。

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

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

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

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

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

输入以下命令可复制 mydataset.mytablemydataset.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 参考文档

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 参考文档

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 参考文档

// 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 参考文档


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 或经典版 BigQuery 网页界面
  • 使用 bq 命令行工具的 bq rm 命令
  • 调用 tables.delete API 方法
  • 使用客户端库

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

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

所需权限

如需删除表,您至少必须具有 bigquery.tables.deletebigquery.tables.get 权限。以下预定义 IAM 角色具有 bigquery.tables.deletebigquery.tables.get 权限:

  • bigquery.dataOwner
  • bigquery.dataEditor
  • bigquery.admin

此外,如果用户具有 bigquery.datasets.create 权限,则当该用户创建数据集时,系统会为其授予该数据集的 bigquery.dataOwner 访问权限。具备 bigquery.dataOwner 访问权限的用户可以在数据集中删除表。

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

删除表

如需删除表,请执行以下操作:

控制台

  1. 资源窗格中选择表。在查询编辑器下方,点击删除表

  2. 在对话框中输入表的名称,然后点击删除以确认删除。

经典版界面

  1. 在导航栏中,点击表名称旁边的向下箭头图标 向下箭头图标。,然后点击 Delete table

  2. 出现提示时,点击 OK 以确认删除。

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 删除 mytablemydataset 属于默认项目。

bq rm -t mydataset.mytable

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

bq rm -t myotherproject:mydataset.mytable

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

bq rm -f -t mydataset.mytable

API

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

C#

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


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 参考文档

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 参考文档

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 参考文档

// 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 参考文档

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 参考文档


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 参考文档

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 天内,您可以恢复删除的表(包括显式删除和因表过期的隐式删除)。通过使用 FOR SYSTEM_TIME AS OF 功能,您可以在删除事件之前引用表并复制该表。

7 天后,您无法使用任何方法恢复删除的表;FOR SYSTEM_TIME AS OF 和其他方式(例如支持服务工单)都不会起作用。

恢复已删除的表

您可以通过以下方式恢复已删除的表:

  • bq 命令行工具中使用 @<time> 快照修饰器
  • 使用客户端库

控制台

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

经典版界面

您无法使用经典版网页界面恢复删除的表。

bq

如需恢复删除的表,请将表复制操作与 @<time> 快照修饰器一起使用。首先,确定指明表存在时间的 UNIX 时间戳(以毫秒为单位)。然后,将该时间戳的表复制到新表。新表不得采用已删除表的名称。

(可选)提供 --location 标志并将其值设置为您的位置

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

bq cp mydataset.mytable@1418864998000 mydataset.newtable

如需了解详情,请参阅旧版 SQL 中的表修饰器

Go

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 参考文档

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 参考文档

// 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 参考文档

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

后续步骤