Gérer les tables

Ce document explique comment gérer les tables dans BigQuery. Vous pouvez gérer vos tables BigQuery comme suit :

Mettez à jour les propriétés de la table :
Renommer (copier) une table
Copier une table
Supprimer une table
Restaurer une table supprimée

Pour en savoir plus sur la création et l'utilisation des tables, y compris sur l'obtention d'informations sur les tables, l'établissement d'une liste des tables et le contrôle de l'accès aux données des tables, consultez la page Créer et utiliser des tables.

Avant de commencer

Attribuez aux utilisateurs des rôles IAM (Identity and Access Management) incluant les autorisations nécessaires pour effectuer l'ensemble des tâches du présent document. Les autorisations requises pour effectuer une tâche (le cas échéant) sont répertoriées dans la section "Autorisations requises" de la tâche.

Mettre à jour les propriétés d'une table

Vous pouvez mettre à jour les éléments suivants d'une table :

Autorisations requises

Pour obtenir les autorisations nécessaires pour mettre à jour les propriétés d'une table, demandez à votre administrateur de vous accorder le rôle IAM Éditeur de données (roles/bigquery.dataEditor) sur une table. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient les autorisations nécessaires pour mettre à jour les propriétés d'une table. Pour afficher les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour mettre à jour les propriétés d'une table :

bigquery.tables.update
bigquery.tables.get

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

En outre, si vous disposez de l'autorisation bigquery.datasets.create, vous pouvez mettre à jour les propriétés des tables des ensembles de données que vous créez.

Mettre à jour la description d'une table

Vous pouvez mettre à jour la description d'une table comme suit :

Utiliser la console Google Cloud
En soumettant une instruction LDD (langage de définition de données) ALTER TABLE
En utilisant la commande bq update de l'outil de ligne de commande bq
Appeler la méthode API tables.patch
En utilisant les bibliothèques clientes

Pour mettre à jour la description d'une table :

Console

Vous ne pouvez pas ajouter de description lorsque vous créez une table à l'aide de la console Google Cloud. Une fois la table créée, vous pouvez ajouter une description sur la page Details (Détails).

Dans le panneau Explorateur, développez votre projet et votre ensemble de données, puis sélectionnez la table.
Dans le panneau des détails, cliquez sur Détails.
Dans la section Description, cliquez sur l'icône en forme de crayon pour modifier la description
Saisissez une description dans la zone de texte, puis cliquez sur Mettre à jour pour enregistrer.

SQL

Utilisez l'instruction ALTER TABLE SET OPTIONS. L'instruction suivante met à jour la description d'une table nommée mytable :

Dans Google Cloud Console, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

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

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq update avec l'option --description. Si vous mettez à jour une table dans un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données en respectant le format suivant : project_id:dataset.
```
bq update \
--description "description" \
project_id:dataset.table
```
Remplacez l'élément suivant :
- description : texte décrivant la table entre guillemets.
- project_id : ID de votre projet.
- dataset : nom de l'ensemble de données contenant la table que vous mettez à jour.
- table : nom de la table que vous mettez à jour.
Exemples :

Pour remplacer la description de la table mytable dans l'ensemble de données mydataset par "Description de ma table", saisissez la commande suivante. L'ensemble de données mydataset se trouve dans votre projet par défaut.
```
bq update --description "Description of mytable" mydataset.mytable
```
Pour remplacer la description de la table mytable dans l'ensemble de données mydataset par "Description de ma table", saisissez la commande suivante. L'ensemble de données mydataset se trouve dans le projet myotherproject, et non dans votre projet par défaut.
```
bq update \
--description "Description of mytable" \
myotherproject:mydataset.mytable
```

API

Appelez la méthode tables.patch et utilisez la propriété description dans la ressource de table pour mettre à jour la description de la table. Étant donné que la méthode tables.update remplace l'intégralité de la ressource de table, la méthode tables.patch est préférable.

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Go.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Java.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Configurez la propriété Table.description et appelez Client.update_table() pour envoyer la mise à jour à l'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."

Mettre à jour le délai d'expiration d'une table

Vous pouvez définir un délai d'expiration de la table par défaut au niveau de l'ensemble de données ou définir le délai d'expiration d'une table lors de sa création. La date/heure d'expiration d'une table est souvent appelée "time to live" (durée de vie) ou valeur TTL.

Lorsqu'une table expire, elle est supprimée avec toutes les données qu'elle contient. Si nécessaire, vous pouvez annuler la suppression de la table dans la période spécifiée pour l'ensemble de données. Pour en savoir plus, consultez la section Restaurer les tables supprimées.

Si vous définissez le délai d'expiration lorsque vous créez la table, la valeur TTL par défaut de l'ensemble de données est ignorée. Si vous ne définissez pas d'expiration de table par défaut au niveau de l'ensemble de données et que vous n'en définissez pas lors de sa création, la table n'expire jamais et vous devez la supprimer manuellement.

Une fois la table créée, vous pouvez mettre à jour ses date et heure d'expiration à tout moment comme suit :

Utiliser la console Google Cloud
En soumettant une instruction LDD (langage de définition de données) ALTER TABLE
En utilisant la commande bq update de l'outil de ligne de commande bq
Appeler la méthode API tables.patch
En utilisant les bibliothèques clientes

Pour mettre à jour la date/heure d'expiration d'une table :

Console

Vous ne pouvez pas ajouter de date/heure d'expiration lorsque vous créez une table à l'aide de la console Google Cloud. Une fois la table créée, vous pouvez ajouter ou mettre à jour le délai d'expiration de la table sur la page Table Details (Détails de la table).

Dans le panneau Explorateur, développez votre projet et votre ensemble de données, puis sélectionnez la table.
Dans le panneau des détails, cliquez sur Détails.
Cliquez sur l'icône en forme de crayon à côté des Table info (Informations sur la table).
Pour Table expiration (Expiration de la table), sélectionnez Specify date (Spécifier une date). Sélectionnez ensuite la date d'expiration à l'aide du widget Agenda.
Cliquez sur Update (Mettre à jour) pour enregistrer la modification. Le délai d'expiration mis à jour apparaît dans la section Table info (Informations sur la table).

SQL

Utilisez l'instruction ALTER TABLE SET OPTIONS. L'exemple suivant met à jour l'heure d'expiration d'une table nommée mytable :

Dans Google Cloud Console, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

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

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq update avec l'option --expiration. Si vous mettez à jour une table dans un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données en respectant le format suivant : project_id:dataset.
```
bq update \
--expiration integer \
project_id:dataset.table
```
Remplacez l'élément suivant :
- integer : durée de vie par défaut (en secondes) de la table. La valeur minimale est de 3 600 secondes (une heure). Le délai d'expiration correspond à l'heure actuelle plus la valeur entière. Si vous spécifiez 0, le délai d'expiration de la table est supprimé, et la table n'expire jamais. Les tables sans délai d'expiration doivent être supprimées manuellement.
- project_id : ID de votre projet.
- dataset : nom de l'ensemble de données contenant la table que vous mettez à jour.
- table : nom de la table que vous mettez à jour.
Exemples :

Pour faire passer le délai d'expiration de la table mytable de l'ensemble de données mydataset à cinq jours (432 000 secondes), saisissez la commande suivante. L'ensemble de données mydataset se trouve dans votre projet par défaut.
```
bq update --expiration 432000 mydataset.mytable
```
Pour faire passer le délai d'expiration de la table mytable de l'ensemble de données mydataset à cinq jours (432 000 secondes), saisissez la commande suivante. L'ensemble de données mydataset se trouve dans le projet myotherproject, et non dans votre projet par défaut.
```
bq update --expiration 432000 myotherproject:mydataset.mytable
```

API

Appelez la méthode tables.patch et utilisez la propriété expirationTime dans la ressource de table pour mettre à jour le délai d'expiration de la table (en millisecondes). Étant donné que la méthode tables.update remplace l'intégralité de la ressource de table, la méthode tables.patch est préférable.

Go

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

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

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

Configurez la propriété Table.expires et appelez Client.update_table() pour envoyer la mise à jour à l'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}.")

Pour mettre à jour le délai d'expiration de la partition de l'ensemble de données par défaut, procédez comme suit :

Java

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

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

Mettre à jour le mode d'arrondi d'une table

Vous pouvez mettre à jour le mode d'arrondi par défaut d'une table à l'aide de l'instruction LDD ALTER TABLE SET OPTIONS. L'exemple suivant met à jour sur ROUND_HALF_EVEN le mode d'arrondi par défaut pour mytable :

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

Lorsque vous ajoutez un champ NUMERIC ou BIGNUMERIC à une table et que vous ne spécifiez pas de mode d'arrondi, celui-ci est automatiquement défini sur le mode d'arrondi par défaut de la table. La modification du mode d'arrondi par défaut d'une table ne modifie pas le mode d'arrondi des champs existants.

Mettre à jour la définition d'un schéma de table

Pour plus d'informations sur la mise à jour de la définition d'un schéma de table, consultez la page Modifier des schémas de table.

Renommer une table

Vous pouvez renommer une table après sa création à l'aide de l'instruction ALTER TABLE RENAME TO. L'exemple suivant renomme mytable en mynewtable :

ALTER TABLE mydataset.mytable
RENAME TO mynewtable;

Limites du changement de nom des tables

Si vous souhaitez renommer une table contenant du streaming de données, vous devez arrêter la diffusion et attendre que BigQuery indique que le streaming n'est pas utilisé.
Une table peut généralement être renommée dans les 72 heures suivant la dernière opération de streaming, mais cela peut prendre plus de temps.
Les LCA de tables et les règles d'accès aux lignes existantes sont conservées, contrairement aux mises à jour des règles d'accès aux lignes et des LCA de tables effectuées lors du changement de nom des tables.
Vous ne pouvez pas renommer une table et exécuter simultanément une instruction LMD sur cette table.
Le fait de renommer une table supprime tous les tags Data Catalog de la table.
Vous ne pouvez pas renommer des tables externes.

Copier une table

Cette section explique comment créer une copie complète d'une table. Pour en savoir plus sur les autres types de copies de tables, consultez les sections Clones de tables et Instantanés de table.

Vous pouvez copier une table comme suit :

Utilisez la console Google Cloud.
Exécutez la commande bq cp.
Utilisez une instruction LDD (langage de définition de données) CREATE TABLE COPY.
Appelez la méthode API jobs.insert et configurez une tâche copy.
Utilisez les bibliothèques client.

Limites de la copie de tables

Les tâches de copie de tables sont soumises aux limites suivantes :

Lorsque vous copiez une table, le nom de la table de destination doit respecter les mêmes conventions d'attribution de noms que lorsque vous créez une table.
Les copies de tables sont soumises aux limites de BigQuery applicables aux tâches de copie.
La console Google Cloud ne permet de copier qu'une seule table à la fois. Vous ne pouvez pas écraser une table existante dans l'ensemble de données de destination. La table doit avoir un nom unique dans l'ensemble de données de destination.
La console Google Cloud ne permet pas de copier plusieurs tables sources dans une table de destination.
Lors de la copie de plusieurs tables sources vers une table de destination à l'aide de l'API, de l'outil de ligne de commande bq ou des bibliothèques clientes, toutes les tables sources doivent avoir des schémas identiques, y compris tout type de partitionnement ou clustering.
Le temps nécessaire à BigQuery pour copier les tables peut varier considérablement selon les exécutions, car le stockage sous-jacent est géré de manière dynamique.
Vous ne pouvez pas copier et ajouter une table source à une table de destination qui contient plus de colonnes que la table source. Les colonnes supplémentaires ont des valeurs par défaut. Au lieu de cela, vous pouvez exécuter INSERT destination_table SELECT * FROM source_table pour copier les données.
Si l'opération de copie écrase une table existante, l'accès au niveau de la table est conservé. Les tags de la table source ne sont pas copiés dans la table écrasée.
Si l'opération de copie crée une table, l'accès au niveau de la table pour la nouvelle table est déterminé par les stratégies d'accès de l'ensemble de données dans lequel la nouvelle table est créée. De plus, les tags sont copiés depuis la table source vers la nouvelle table.
Lorsque vous copiez plusieurs tables sources dans une table de destination, toutes les tables sources doivent contenir des tags identiques.

Rôles requis

Pour effectuer les tâches décrites dans ce document, vous devez disposer des autorisations suivantes.

Rôles pour copier des tables et des partitions

Pour obtenir les autorisations nécessaires pour copier des tables et des partitions, demandez à votre administrateur de vous accorder le rôle IAM Éditeur de données (roles/bigquery.dataEditor) sur les ensembles de données source et de destination. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient les autorisations nécessaires pour copier des tables et des partitions. Pour afficher les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour copier des tables et des partitions :

bigquery.tables.getData sur les ensembles de données source et de destination
bigquery.tables.get sur les ensembles de données source et de destination
bigquery.tables.create sur l'ensemble de données de destination
bigquery.tables.update sur l'ensemble de données de destination

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Autorisation pour exécuter une tâche de copie

Pour obtenir l'autorisation pour exécuter un job de copie, demandez à votre administrateur de vous accorder le rôle IAM Utilisateur de job (roles/bigquery.jobUser) sur les ensembles de données source et de destination. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient l'autorisation bigquery.jobs.create, qui est nécessaire pour exécuter une tâche de copie.

Vous pouvez également obtenir cette autorisation avec des rôles personnalisés ou d'autres rôles prédéfinis.

Copier une seule table source

Vous pouvez copier une seule table comme suit :

Utiliser la console Google Cloud
En utilisant la commande bq cp de l'outil de ligne de commande bq
En soumettant une instruction LDD (langage de définition de données) CREATE TABLE COPY
En appelant la méthode API jobs.insert, en configurant une tâche de copie (copy) et en spécifiant la propriété sourceTable
Utiliser les bibliothèques clientes

La console Google Cloud et l'instruction CREATE TABLE COPY n'acceptent qu'une table source et une table de destination dans une tâche de copie. Pour copier plusieurs fichiers sources dans une table de destination, vous devez utiliser l'outil de ligne de commande bq ou l'API.

Pour copier une seule table source :

Console

Dans le panneau Explorateur, développez votre projet et votre ensemble de données, puis sélectionnez la table.
Dans le panneau de détails, cliquez sur Copier une table.
Dans la boîte de dialogue Copy table (Copier la table), sous Destination :
- Pour Nom du projet, choisissez le projet qui hébergera la table copiée.
- Pour Nom de l'ensemble de données, sélectionnez l'ensemble de données dans lequel vous souhaitez stocker la table copiée. Les ensembles de données source et de destination doivent être stockés dans le même emplacement.
- Pour Table name (Nom de la table), saisissez un nom pour la nouvelle table. Le nom doit être unique dans l'ensemble de données de destination. Vous ne pouvez pas écraser une table existante dans l'ensemble de données de destination à l'aide de la console Google Cloud. Pour plus d'informations sur les exigences concernant les noms de table, consultez la page Nommer les tables.
Cliquez sur Copier pour démarrer la tâche de copie.

SQL

Utilisez l'instruction CREATE TABLE COPY pour copier une table nommée table1 dans une nouvelle table nommée table1copy :

Dans Google Cloud Console, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

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

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq cp. Les indicateurs facultatifs peuvent être utilisés pour contrôler la disposition d'écriture de la table de destination :
- -a ou --append_table ajoute les données de la table source à une table existante de l'ensemble de données de destination.
- -f ou --force écrase une table existante dans l'ensemble de données de destination, et ne vous demande pas de confirmation.
- -n ou --no_clobber renvoie le message d'erreur suivant si la table existe dans l'ensemble de données de destination : Table 'project_id:dataset.table' already exists, skipping. Si -n n'est pas spécifié, le comportement par défaut consiste à vous demander si vous souhaitez remplacer la table de destination.
- --destination_kms_key est la clé Cloud KMS gérée par le client et utilisée pour chiffrer la table de destination.
--destination_kms_key n'est pas présenté ici. Pour en savoir plus, consultez la page Protéger des données avec des clés Cloud Key Management Service.

Si l'ensemble de données source ou de destination se trouve dans un projet autre que votre projet par défaut, ajoutez l'ID du projet aux noms des ensembles de données en respectant le format suivant : project_id:dataset.

(Facultatif) Spécifiez l'option --location et définissez la valeur correspondant à votre emplacement.
```
bq --location=location cp \
-a -f -n \
project_id:dataset.source_table \
project_id:dataset.destination_table
```
Remplacez l'élément suivant :
- location : nom de votre emplacement. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement à l'aide du fichier .bigqueryrc.
- project_id : ID de votre projet.
- dataset : nom de l'ensemble de données source ou de destination.
- source_table : la table que vous copiez.
- destination_table : nom de la table dans l'ensemble de données de destination.
Exemples :

Pour copier la table mydataset.mytable vers la table mydataset2.mytable2, saisissez la commande suivante. Les deux ensembles de données sont dans votre projet par défaut.
```
bq cp mydataset.mytable mydataset2.mytable2
```
Pour copier la table mydataset.mytable et écraser une table de destination portant le même nom, saisissez la commande suivante. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans le projet myotherproject. Le raccourci -f permet d'écraser la table de destination sans invite.
```
bq cp -f \
mydataset.mytable \
myotherproject:myotherdataset.mytable
```
Pour copier la table mydataset.mytable et renvoyer une erreur si l'ensemble de données de destination contient une table portant le même nom, saisissez la commande suivante. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans le projet myotherproject. Le raccourci -n permet d'éviter d'écraser une table portant le même nom.
```
bq cp -n \
mydataset.mytable \
myotherproject:myotherdataset.mytable
```
Pour copier la table mydataset.mytable et ajouter les données à une table de destination portant le même nom, utilisez la commande suivante. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans le projet myotherproject. Le raccourci - a permet d'ajouter des données à la table de destination.
```
bq cp -a mydataset.mytable myotherproject:myotherdataset.mytable
```

API

Vous pouvez copier une table existante via l'API en appelant la méthode bigquery.jobs.insert et en configurant une tâche de copie (copy). Spécifiez l'emplacement dans la propriété location de la section jobReference de la ressource de tâche.

Vous devez spécifier les valeurs suivantes dans votre configuration de tâche :

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

Où sourceTable fournit des informations sur la table à copier, destinationTable fournit des informations sur la nouvelle table, createDisposition précise si la table doit être créée si elle n'existe pas, et writeDisposition indique s'il convient d'écraser une table existante ou d'y ajouter des données.

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour C#.


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

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

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

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour PHP du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour PHP.

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


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

Copier plusieurs tables sources

Vous pouvez copier plusieurs tables sources dans une table de destination comme suit :

En utilisant la commande bq cp de l'outil de ligne de commande bq
En appelant la méthode jobs.insert, en configurant une tâche de copie (copy) et en spécifiant la propriété sourceTables
Utiliser les bibliothèques clientes

Toutes les tables sources doivent avoir des schémas et des tags identiques, et une seule table de destination est autorisée.

Vous devez spécifier les tables sources sous forme de liste en les séparant par une virgule. Vous ne pouvez pas utiliser de caractères génériques lorsque vous copiez plusieurs tables sources.

Pour copier plusieurs tables sources, sélectionnez l'une des options suivantes :

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq cp et incluez plusieurs tables sources sous forme de liste séparée par des virgules. Les indicateurs facultatifs peuvent être utilisés pour contrôler la disposition d'écriture de la table de destination :
- -a ou --append_table ajoute les données des tables sources à une table existante de l'ensemble de données de destination.
- -f ou --force écrase une table de destination existante dans l'ensemble de données de destination, et ne vous demande pas de confirmation.
- -n ou --no_clobber renvoie le message d'erreur suivant si la table existe dans l'ensemble de données de destination : Table 'project_id:dataset.table' already exists, skipping. Si -n n'est pas spécifié, le comportement par défaut consiste à vous demander si vous souhaitez remplacer la table de destination.
- --destination_kms_key est la clé Cloud Key Management Service gérée par le client et utilisée pour chiffrer la table de destination.
--destination_kms_key n'est pas présenté ici. Pour en savoir plus, consultez la page Protéger des données avec des clés Cloud Key Management Service.

Si l'ensemble de données source ou de destination se trouve dans un projet autre que votre projet par défaut, ajoutez l'ID du projet aux noms des ensembles de données en respectant le format suivant : project_id:dataset.

(Facultatif) Spécifiez l'option --location et définissez la valeur correspondant à votre emplacement.
```
bq --location=location cp \
-a -f -n \
project_id:dataset.source_table,project_id:dataset.source_table \
project_id:dataset.destination_table
```
Remplacez l'élément suivant :
- location : nom de votre emplacement. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement à l'aide du fichier .bigqueryrc.
- project_id : ID de votre projet.
- dataset : nom de l'ensemble de données source ou de destination.
- source_table : table que vous copiez.
- destination_table : nom de la table dans l'ensemble de données de destination.
Exemples :

Pour copier la table mydataset.mytable et la table mydataset.mytable2 vers la table mydataset2.tablecopy, saisissez la commande suivante : Tous les ensembles de données sont dans votre projet par défaut.
```
bq cp \
mydataset.mytable,mydataset.mytable2 \
mydataset2.tablecopy
```
Pour copier la table mydataset.mytable et la table mydataset.mytable2 vers la table myotherdataset.mytable, et pour écraser une table de destination portant le même nom, saisissez la commande suivante. L'ensemble de données de destination se trouve dans le projet myotherproject, et non dans votre projet par défaut. Le raccourci -f permet d'écraser la table de destination sans invite.
```
bq cp -f \
mydataset.mytable,mydataset.mytable2 \
myotherproject:myotherdataset.mytable
```
Pour copier la table myproject:mydataset.mytable et la table myproject:mydataset.mytable2, et renvoyer une erreur si l'ensemble de données de destination contient une table portant le même nom, saisissez la commande suivante. L'ensemble de données de destination se trouve dans le projet myotherproject. Le raccourci -n permet d'éviter d'écraser une table portant le même nom.
```
bq cp -n \
myproject:mydataset.mytable,myproject:mydataset.mytable2 \
myotherproject:myotherdataset.mytable
```
Pour copier la table mydataset.mytable et la table mydataset.mytable2, et pour ajouter les données à une table de destination portant le même nom, saisissez la commande suivante. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans le projet myotherproject. Le raccourci -a permet d'ajouter des données à la table de destination.
```
bq cp -a \
mydataset.mytable,mydataset.mytable2 \
myotherproject:myotherdataset.mytable
```

API

Pour copier plusieurs tables à l'aide de l'API, appelez la méthode jobs.insert, configurez une tâche de copie (copy) de table et spécifiez la propriété sourceTables.

Spécifiez la région dans la propriété location de la section jobReference de la ressource de tâche.

Go

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

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

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


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

Copier des tables d'une région à une autre

Pour demander l'accès à cette fonctionnalité en preview, remplissez le formulaire d'inscription en preview à la copie interrégionale de la table BigQuery.

Vous pouvez copier une table, un instantané de table ou un clone de table d'une région BigQuery ou d'un emplacement multirégional à un autre. Cela inclut toutes les tables sur lesquelles les clés Cloud KMS gérées par le client (CMEK) sont appliquées. Cela entraîne des frais supplémentaires conformément aux tarifs de BigQuery.

Pour copier une table d'une région à une autre, sélectionnez l'une des options suivantes :

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq cp :

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

Remplacez les éléments suivants :

SOURCE_PROJECT : ID du projet source. Si l'ensemble de données source se trouve dans un projet autre que celui par défaut, ajoutez l'ID du projet au nom de l'ensemble de données source.
DESTINATION_PROJECT : ID du projet de destination Si l'ensemble de données de destination se trouve dans un projet autre que celui par défaut, ajoutez l'ID du projet au nom de l'ensemble de données de destination.
SOURCE_DATASET : nom de l'ensemble de données source
DESTINATION_DATASET : nom de l'ensemble de données de destination
SOURCE_TABLE : table que vous copiez.
DESTINATION_TABLE : nom de la table dans l'ensemble de données de destination.

Exemples :

Pour copier la table mydataset_us.mytable de l'emplacement multirégional us vers la table mydataset_eu.mytable2 de l'emplacement multirégional eu, saisissez la commande suivante : Les deux ensembles de données sont dans votre projet par défaut.
```
bq cp --sync=false mydataset_us.mytable mydataset_eu.mytable2
```
Pour copier une table compatible avec les CMEK, vous pouvez créer une clé à l'aide de Cloud KMS et la spécifier dans la commande bq cp, ou utiliser un ensemble de données de destination avec une clé CMEK par défaut configurée. L'exemple suivant spécifie la clé CMEK de destination dans la commande bq cp.
```
bq cp ----destination_kms_key=projects/testing/locations/us/keyRings/us_key/cryptoKeys/eu_key mydataset_us.mytable mydataset_eu.mytable2
```

API

Pour copier une table dans plusieurs régions à l'aide de l'API, appelez la méthode jobs.insert et configurez un job de copie copy.

Spécifiez la région dans la propriété location de la section jobReference de la ressource de tâche.

C#


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

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

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

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

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


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

Limites

La copie d'une table dans plusieurs régions est soumise aux limites suivantes :

Vous ne pouvez pas copier de table à l'aide de la console Google Cloud ou de l'instruction TABLE COPY DDL.
Vous ne pouvez pas copier une table s'il existe des tags avec stratégie dans la table source.
Vous ne pouvez pas copier des stratégies IAM associées aux tables. Vous pouvez appliquer les mêmes règles à la destination une fois la copie terminée.
Vous ne pouvez pas copier plusieurs tables sources dans une même table de destination.
Vous ne pouvez pas copier des tables en mode d'ajout.
Les informations sur les plages temporelles ne sont pas copiées dans la région de destination.
Les clones de table sont convertis en copie complète dans la région de destination.

Afficher l'utilisation actuelle des quotas

Vous pouvez afficher l'utilisation actuelle des jobs de requête, de chargement, d'extraction ou de copie en exécutant une requête INFORMATION_SCHEMA pour afficher les métadonnées des tâches exécutées sur une période spécifiée. Vous pouvez comparer votre utilisation actuelle à la limite de quota pour déterminer votre utilisation de quotas pour un type de job particulier. L'exemple de requête suivant utilise la vue INFORMATION_SCHEMA.JOBS pour répertorier le nombre de jobs de requête, de chargement, d'extraction et de copie par projet :

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

Pour afficher les limites de quota pour les jobs de copie, consultez la section Quotas et limites : jobs de copie.

Supprimer des tables

Vous pouvez supprimer une table comme suit :

Utiliser la console Google Cloud
En soumettant une instruction LDD (langage de définition de données) DROP TABLE
En utilisant la commande bq rm de l'outil de ligne de commande bq
Appeler la méthode API tables.delete
Utiliser les bibliothèques clientes

Pour supprimer toutes les tables de l'ensemble de données, supprimez l'ensemble de données.

Lorsque vous supprimez une table, toutes les données de la table sont également supprimées. Pour supprimer automatiquement des tables après une période donnée, définissez le délai d'expiration par défaut de la table pour l'ensemble de données ou spécifiez le délai d'expiration lorsque vous créez la table.

La suppression d'une table supprime également toutes les autorisations associées à cette table. Lorsque vous recréez une table supprimée, vous devez également reconfigurer manuellement les autorisations d'accès qui lui sont associées.

Rôles requis

Pour obtenir les autorisations nécessaires pour supprimer une table, demandez à votre administrateur de vous accorder l'autorisation le rôle IAM Éditeur de données (roles/bigquery.dataEditor) sur l'ensemble de données. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient les autorisations nécessaires pour supprimer une table. Pour afficher les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour supprimer une table :

bigquery.tables.delete
bigquery.tables.get

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Supprimer une table

Pour supprimer une table :

Console

Dans le panneau Explorateur, développez votre projet et votre ensemble de données, puis sélectionnez la table.
Dans le panneau de détails, cliquez sur Supprimer la table.
Saisissez "delete" dans la boîte de dialogue, puis cliquez sur Supprimer pour confirmer.

SQL

Utilisez l'instruction DROP TABLE. L'exemple suivant supprime une table nommée mytable :

Dans Google Cloud Console, accédez à la page BigQuery.

Accéder à BigQuery
Dans l'éditeur de requête, saisissez l'instruction suivante :
```
DROP TABLE mydataset.mytable;
```
Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Exécutez la commande bq rm avec l'option --table (ou le raccourci -t) pour supprimer une table. Lorsque vous supprimez une table à l'aide de l'outil de ligne de commande bq, vous devez confirmer l'action. Vous pouvez utiliser l'option --force (ou le raccourci -f) pour ignorer la confirmation.

Si la table se trouve dans un ensemble de données d'un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données en respectant le format suivant : project_id:dataset.
```
bq rm \
-f \
-t \
project_id:dataset.table
```
Remplacez l'élément suivant :
- project_id : ID de votre projet.
- dataset : nom de l'ensemble de données contenant la table.
- table : nom de la table que vous supprimez.
Exemples :

Pour supprimer la table mytable de l'ensemble de données mydataset, saisissez la commande suivante. L'ensemble de données mydataset se trouve dans votre projet par défaut.
```
bq rm -t mydataset.mytable
```
Pour supprimer la table mytable de l'ensemble de données mydataset, saisissez la commande suivante. L'ensemble de données mydataset se trouve dans le projet myotherproject, et non dans votre projet par défaut.
```
bq rm -t myotherproject:mydataset.mytable
```
Pour supprimer la table mytable de l'ensemble de données mydataset, saisissez la commande suivante. L'ensemble de données mydataset se trouve dans votre projet par défaut. La commande utilise le raccourci -f pour contourner la confirmation.
```
bq rm -f -t mydataset.mytable
```
Remarque : Vous pouvez saisir la commande bq ls dataset dans l'outil de ligne de commande bq pour confirmer qu'une table a été supprimée d'un ensemble de données.

API

Appelez la méthode API tables.delete et spécifiez la table à supprimer à l'aide du paramètre tableId.

C#


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

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

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

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

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


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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Ruby du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Ruby.

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

Restaurer les tables supprimées

Vous pouvez annuler la suppression d'une table pendant la période spécifiée pour l'ensemble de données, y compris les suppressions explicites et implicites dues à l'expiration de la table. Vous pouvez configurer la fenêtre de fonctionnalité temporelle.

La période temporelle peut durer entre deux et sept jours. Une fois le délai écoulé, il n'est plus possible d'annuler la suppression d'une table, quelle que soit la méthode utilisée, y compris pour ouvrir une demande d'assistance.

Lorsque vous restaurez une table partitionnée qui a été supprimée car elle a expiré, vous devez recréer manuellement les partitions.

Lorsque vous restaurez une table à partir de données historiques, les tags de la table source ne sont pas copiés dans la table de destination.

Vous pouvez restaurer une table supprimée, mais toujours dans la fenêtre temporelle, en copiant la table dans une nouvelle table, à l'aide du décorateur d'heure @<time>. Pour copier la table, vous pouvez utiliser l'outil de ligne de commande bq ou les bibliothèques clientes :

Console

Vous ne pouvez pas annuler la suppression d'une table à l'aide de la console Google Cloud.

bq

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Pour restaurer une table, commencez par déterminer un horodatage UNIX (en millisecondes) correspondant à la période d'existence de la table. Vous pouvez utiliser la commande Linux date pour générer l'horodatage Unix à partir d'une valeur d'horodatage standard :
```
date -d '2023-08-04 16:00:34.456789Z' +%s000
```
Exécutez ensuite la commande bq copy avec le décorateur de fonctionnalité temporelle @<time> pour effectuer l'opération de copie de table.

Par exemple, saisissez la commande suivante pour copier la table mydataset.mytable au moment 1418864998000 dans une nouvelle table mydataset.newtable.
```
bq cp mydataset.mytable@1418864998000 mydataset.newtable
```
(Facultatif) Spécifiez l'option --location et définissez la valeur correspondant à votre emplacement.

Vous pouvez également spécifier un décalage relatif. L'exemple suivant copie la version d'une table d'il y a une heure :
```
bq cp mydataset.mytable@-3600000 mydataset.newtable
```
Pour plus d'informations, consultez la section Restaurer une table à un moment précis.

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

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

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

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

Si vous prévoyez de restaurer une table ultérieurement à ce qui est autorisé par la fenêtre temporelle, créez un instantané de la table. Pour en savoir plus, consultez la section Instantanés de table.

Sécurité des tables

Pour savoir comment contrôler l'accès aux tables dans BigQuery, consultez la page Présentation des contrôles d'accès aux tables.

Étape suivante

Pour plus d'informations sur la création et l'utilisation des tables, consultez la page Créer et utiliser des tables.
Pour plus d'informations sur la gestion des données, consultez la page Gérer des données de table.
Pour en savoir plus sur la spécification des schémas de table, consultez la page Spécifier un schéma.
Pour en savoir plus sur la modification des schémas de table, consultez la page Modifier des schémas de table.
Pour en savoir plus sur les ensembles de données, consultez la page Présentation des ensembles de données.
Pour plus d'informations sur les vues, consultez la page Présentation des vues.