Gérer des tables

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

  • Mettre à jour une table :
    • Date/Heure d'expiration
    • Description
    • Définition du schéma
    • Libellés
  • Renommer (copier) une table
  • Copier une table
  • Supprimer une table
  • Restaurer une table supprimée

Pour plus d'informations sur la création et l'utilisation des tables, y compris la collecte des informations dans les tables, la liste des tables et le contrôle de l'accès aux données des tables, consultez la section Créer et utiliser des tables.

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

Vous pouvez mettre à jour les propriétés d'une table :

Autorisations requises

Pour mettre à jour les propriétés d'une table, vous devez disposer d'un accès WRITER au niveau de l'ensemble de données ou d'un rôle IAM au niveau du projet qui inclut les autorisations bigquery.tables.update. Voici les rôles IAM prédéfinis au niveau du projet qui incluent les autorisations bigquery.tables.update :

De plus, comme le rôle bigquery.user dispose des autorisations bigquery.datasets.create, tout utilisateur bénéficiant du rôle de bigquery.user peut mettre à jour n'importe quelle table créée par un utilisateur dans l'ensemble de données. Lorsqu'un utilisateur ayant le rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à cet ensemble de données. L'accès OWNER à un ensemble de données confère à l'utilisateur un contrôle total sur celui-ci, et sur toutes les tables et les vues qu'il contient.

Pour en savoir plus sur les autorisations et les rôles IAM dans BigQuery, consultez la page Contrôle des accès.

Mettre à jour la description d'une table

Vous pouvez mettre à jour la description d'une table à l'aide des méthodes suivantes :

  • Utilisation de la console GCP ou de l'interface utilisateur Web classique de BigQuery
  • Utilisation de la commande CLI bq update
  • Appel de la méthode d'API tables.patch

Pour mettre à jour la description d'une table :

Interface utilisateur classique

Avec l'interface utilisateur Web classique de BigQuery, vous ne pouvez pas ajouter de description au moment de la création d'une table. Une fois la table créée, vous pouvez ajouter la description sur la page Table Details (Détails de la table).

  1. Dans le volet de navigation, sélectionnez la table.

  2. Sur la page Table Details (Détails de la table), cliquez sur Details (Détails).

  3. Dans la section Description, cliquez sur Describe this table (Décrire cette table) pour ouvrir la zone de description.

  4. Entrez une description dans la zone. Cliquez en dehors de la zone pour enregistrer le texte.

    Description de la table

CLI

Exécutez la commande bq update avec l'indicateur --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 au format suivant : [PROJECT_ID]:[DATASET].

bq update --description "[DESCRIPTION]" [PROJECT_ID]:[DATASET].[TABLE]

Où :

  • [DESCRIPTION] est le texte décrivant la table entre guillemets.
  • [PROJECT_ID] est l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données contenant la table que vous mettez à jour.
  • [TABLE] est le nom de la table que vous mettez à jour.

Exemples :

Entrez la commande suivante pour remplacer la description de la table mytable dans mydataset par "Description of mytable". L'ensemble de données mydataset est dans votre projet par défaut.

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

Entrez la commande suivante pour remplacer la description de la table mytable dans mydataset par "Description of mytable". L'ensemble de données mydataset est dans myotherproject, et non pas 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 pour mettre à jour la description de la table dans la ressource de 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 l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le 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 Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

// String datasetName = "my_dataset_name";
// String tableName = "my_table_name";
// String newDescription = "new_description";

Table beforeTable = bigquery.getTable(datasetName, tableName);
TableInfo tableInfo = beforeTable.toBuilder()
    .setDescription(newDescription)
    .build();
Table afterTable = bigquery.update(tableInfo);

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 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()
# table_ref = client.dataset('my_dataset').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 la date/heure d'expiration d'une table

Vous pouvez définir une date/heure d'expiration de la table par défaut au niveau de l'ensemble de données ou définir la date/heure 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.

Si vous définissez l'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.

À tout moment après la création de la table, vous pouvez mettre à jour sa date/heure d'expiration à l'aide des méthodes suivantes :

  • Utilisation de la console GCP ou de l'interface utilisateur Web classique de BigQuery
  • Utilisation de la commande CLI bq update
  • Appel de la méthode d'API tables.patch

Lorsque vous mettez à jour la date/heure d'expiration d'une table, vous devez calculer l'expiration en fonction de sa date et de son heure de création. Par exemple, si votre table a été créée le 3 janvier 2018 et que nous sommes le 5 janvier, si vous définissez le délai d'expiration sur 1 jour, celui-ci est considéré comme étant "dans le passé", et la table est supprimée immédiatement.

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

Interface utilisateur classique

Avec l'interface utilisateur Web classique de BigQuery, vous ne pouvez pas ajouter la date/heure d'expiration au moment de la création d'une table. Une fois la table créée, vous pouvez l'ajouter ou la mettre à jour sur la page Table Details (Détails de la table).

  1. Dans le volet de navigation, sélectionnez la table.

  2. Sur la page Table Details (Détails de la table), cliquez sur Details (Détails).

  3. Pour le champ Expiration Time (Date/heure d'expiration), cliquez sur Edit (Modifier).

  4. Dans la boîte de dialogue Mettre à jour le délai d'expiration, cliquez sur Dans et saisissez un délai d'expiration en jours.

  5. Cliquez sur OK. Le délai d'expiration mis à jour apparaît sur la page Details (Détails).

    Expiration de la table

CLI

Exécutez la commande bq update avec l'indicateur --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 au format suivant : [PROJECT_ID]:[DATASET].

bq update --expiration [INTEGER] [PROJECT_ID]:[DATASET].[TABLE]

Où :

  • [INTEGER] est la 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.
  • [PROJECT_ID] est l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données contenant la table que vous mettez à jour.
  • [TABLE] est le nom de la table que vous mettez à jour.

Exemples :

Entrez la commande suivante pour mettre à jour la date/heure d'expiration de mytable dans mydataset à 5 jours (432 000 secondes). mydataset est dans votre projet par défaut.

bq update --expiration 432000 mydataset.mytable

Entrez la commande suivante pour mettre à jour la date/heure d'expiration de mytable dans mydataset à 5 jours (432 000 secondes). mydataset est dans myotherproject, et pas 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 pour mettre à jour la date/heure d'expiration de la table (en millisecondes). Comme la méthode tables.update remplace la totalité de la ressource de table, la méthode tables.patch est préférable.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le 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 Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

Table beforeTable = bigquery.getTable(datasetName, tableName);

// Set table to expire 5 days from now.
long expirationMillis = DateTime.now().plusDays(5).getMillis();
TableInfo tableInfo = beforeTable.toBuilder()
        .setExpirationTime(expirationMillis)
        .build();
Table afterTable = bigquery.update(tableInfo);

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

Configurez la propriété table.expires et appelez client.update_table () pour envoyer la mise à jour à l'API.

import datetime
import pytz

# from google.cloud import bigquery
# client = bigquery.Client()
# table_ref = client.dataset('my_dataset').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

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 Modifier des schémas de table.

Renommer une table

Vous ne pouvez pas modifier le nom d'une table existante. Si vous devez modifier le nom de la table, suivez les étapes pour copier la table. Lorsque vous spécifiez la table de destination dans l'opération de copie, indiquez le nouveau nom de table.

Copier une table

Vous pouvez copier une table à l'aide des méthodes suivantes :

  • Utilisation de la console GCP ou de l'interface utilisateur Web classique de BigQuery
  • Utilisation de la commande bq cp de l'outil de ligne de commande
  • Appel de la méthode API jobs.insert et configuration d'une tâche de copie

Autorisations requises

Au niveau de l'ensemble de données, la copie d'une table nécessite un accès READER à l'ensemble de données source contenant la table copiée et un accès WRITER à l'ensemble de données de destination.

Au lieu d'utiliser des autorisations au niveau des ensembles de données, vous pouvez tirer parti du rôle IAM au niveau du projet qui inclut les autorisations bigquery.tables.create et bigquery.tables.getData. Les autorisations bigquery.tables.create sont requises pour créer la copie de la table dans l'ensemble de données de destination. Les autorisations bigquery.tables.getData sont nécessaires pour lire les données de la table en cours de copie.

Les rôles IAM prédéfinis au niveau du projet incluent les autorisations bigquery.tables.create et bigquery.tables.getData pour chaque ensemble de données du projet :

De plus, comme le rôle bigquery.user possède des autorisations bigquery.datasets.create, un utilisateur affecté au rôle bigquery.user peut lire les données de toute table qu'il crée et créer une copie de la table dans tout ensemble de données qu'il crée. Lorsqu'un utilisateur détenant le rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à celui-ci. L'accès OWNER à un ensemble de données donne à l'utilisateur un contrôle total sur celui-ci et sur toutes les tables qu'il contient.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la section Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

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 règles de quota de BigQuery sur les tâches de copie.
  • Lorsque vous utilisez la console GCP ou l'interface utilisateur Web classique de BigQuery pour copier une table, 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.
  • Lorsque vous copiez des tables, l'ensemble de données de destination doit se trouver dans le même emplacement que l'ensemble de données contenant la table à copier. Par exemple, vous ne pouvez pas copier une table à partir d'un ensemble de données basé au sein de l'UE et l'écrire dans un ensemble de données basé aux États-Unis.
  • La copie de plusieurs tables sources dans une table de destination n'est pas acceptée dans la console GCP ou l'interface utilisateur Web classique de BigQuery.
  • Lors de la copie de plusieurs tables sources vers une table de destination à l'aide de la CLI ou de l'API, toutes les tables sources doivent contenir des schémas identiques.

Copier une seule table source

Vous pouvez copier une seule table à l'aide des méthodes suivantes :

  • Utilisation de la console GCP ou de l'interface utilisateur Web classique de BigQuery
  • Utilisation de la commande bq cp de l'outil de ligne de commande
  • Appel de la méthode API jobs.insert, configuration d'une tâche de copie et spécification de la propriété configuration.copy.sourceTable

La console GCP et l'interface utilisateur Web classique de BigQuery 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 ou l'API.

Pour copier une seule table source :

Interface utilisateur classique

  1. Cliquez sur l'icône du menu d'affichage flèche vers le bas qui est située à côté de la table que vous souhaitez copier, puis sur Copy Table (Copier la table).

  2. Dans la boîte de dialogue Copy Table (Copier la table) :

    • Pour le champ Destination Project (Projet de destination), choisissez le projet qui stockera la table copiée.
    • Pour le champ Destination dataset (Ensemble de données de destination), sélectionnez l'ensemble de données dans lequel vous souhaitez stocker la table copiée. Les ensembles de données sources et de destination doivent être stockés dans le même emplacement.
    • Pour le champ Destination Table (Table de destination), saisissez un nom pour la nouvelle table. Le nom doit être unique dans l'ensemble de données de destination. Le nom de la table peut contenir jusqu'à 1 024 caractères et uniquement les caractères de a à z, A à Z, 0 à 9 ou _ (le caractère de soulignement). Vous ne pouvez pas écraser une table existante dans l'ensemble de données de destination avec l'interface utilisateur Web BigQuery.

      Copie de table

  3. Cliquez sur OK pour démarrer la tâche de copie.

Ligne de commande

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 invite pas à confirmer l'action.
  • -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. Consultez la page Protéger des données avec des clés Cloud KMS pour plus d'informations.

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

Spécifiez l'indicateur --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]

où :

  • [LOCATION] est le nom de votre emplacement. L'indicateur --location est facultatif. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, définissez la valeur de l'indicateur sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
  • [PROJECT_ID] est l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données source ou de destination.
  • [SOURCE_TABLE] est la table que vous copiez.
  • [DESTINATION_TABLE] est le nom de la table dans l'ensemble de données de destination.

Exemples :

Entrez la commande suivante pour copier mydataset.mytable dans mydataset2.mytable2. Les deux ensembles de données sont dans votre projet par défaut et ont été créés dans l'emplacement multirégional US.

bq --location=US cp mydataset.mytable mydataset2.mytable2

Entrez la commande suivante pour copier mydataset.mytable et écraser une table de destination portant le même nom. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans myotherproject. Le raccourci -f est utilisé pour écraser la table de destination sans invite. mydataset et myotherdataset ont été créés dans l'emplacement multirégional US.

bq --location=US cp -f mydataset.mytable myotherproject:myotherdataset.mytable

Entrez la commande suivante pour copier mydataset.mytable et renvoyer une erreur si l'ensemble de données de destination contient une table portant le même nom. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans myotherproject. Le raccourci -n permet d'éviter d'écraser une table portant le même nom. Les deux ensembles de données ont été créés dans l'emplacement multirégional US.

bq --location=US cp -n mydataset.mytable myotherproject:myotherdataset.mytable

Entrez la commande suivante pour copier un objet mydataset.mytable et ajouter les données à une table de destination portant le même nom. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans myotherproject. Le raccourci -a est utilisé pour ajouter à la table de destination. Les deux ensembles de données ont été créés dans l'emplacement multirégional US.

bq --location=US cp -a mydataset.mytable myotherproject:myotherdataset.mytable

Entrez la commande suivante pour copier mydataset.mytable dans mydataset2.mytable2. Les deux ensembles de données sont dans votre projet par défaut. Les deux ensembles de données ont été créés dans la région asia-northeast1.

bq --location=asia-northeast1 cp mydataset.mytable mydataset2.mytable2

API

Copier une table avec l'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 type copy. Spécifiez votre 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
    },

sourceTable fournit des informations sur la table à copier, destinationTable spécifie la nouvelle table, createDisposition précise s'il faut créer la table dans le cas où elle n'existe pas et writeDisposition indique s'il convient de l'ajouter à une table ou de l'utiliser pour écraser une table existante.

C#

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour C# dans le 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 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.
        // 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

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le 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 Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

TableId destinationId = TableId.of(dataset, tableName);
JobOption options = JobOption.fields(JobField.STATUS, JobField.USER_EMAIL);
Job job = table.copy(destinationId, options);
// Wait for the job to complete.
try {
  Job completedJob =
      job.waitFor(
          RetryOption.initialRetryDelay(Duration.ofSeconds(1)),
          RetryOption.totalTimeout(Duration.ofMinutes(3)));
  if (completedJob != null && completedJob.getStatus().getError() == null) {
    // Job completed successfully.
  } else {
    // Handle error case.
  }
} catch (InterruptedException e) {
  // Handle interrupted wait
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Node.js dans le 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 Node.js.

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

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

// Creates a client
const bigquery = new BigQuery({projectId});

// Copies 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 l'exemple ci-dessous, suivez la procédure de configuration pour PHP dans le 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 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

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()

source_dataset = client.dataset('samples', project='bigquery-public-data')
source_table_ref = source_dataset.table('shakespeare')

# dataset_id = 'my_dataset'
dest_table_ref = client.dataset(dataset_id).table('destination_table')

job = client.copy_table(
    source_table_ref,
    dest_table_ref,
    # Location must match that of the source and destination tables.
    location='US')  # API request

job.result()  # Waits for job to complete.

assert job.state == 'DONE'
dest_table = client.get_table(dest_table_ref)  # API request
assert dest_table.num_rows > 0

Copier plusieurs tables sources

Vous pouvez copier plusieurs tables sources dans une table de destination à l'aide des méthodes suivantes :

Toutes les tables sources doivent avoir des schémas 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 :

Ligne de commande

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 invite pas à confirmer l'action.
  • -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. Consultez la page Protéger des données avec des clés Cloud KMS pour plus d'informations.

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

Spécifiez l'indicateur --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]

où :

  • [LOCATION] est le nom de votre emplacement. L'indicateur --location est facultatif. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, définissez la valeur de l'indicateur sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
  • [PROJECT_ID] est l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données source ou de destination.
  • [SOURCE_TABLE] est la table que vous copiez.
  • [DESTINATION_TABLE] est le nom de la table dans l'ensemble de données de destination.

Exemples :

Entrez la commande suivante pour copier mydataset.mytable et mydataset.mytable2 dans mydataset2.tablecopy. Tous les ensembles de données se trouvent dans votre projet par défaut et ont été créés dans l'emplacement multirégional US.

bq --location=US cp mydataset.mytable,mydataset.mytable2 mydataset2.tablecopy

Entrez la commande suivante pour copier mydataset.mytable et mydataset.mytable2 dans myotherdataset.mytable et écraser une table de destination portant le même nom. L'ensemble de données de destination est dans myotherproject, pas dans votre projet par défaut. Le raccourci -f est utilisé pour écraser la table de destination sans invite. Les deux ensembles de données ont été créés dans l'emplacement multirégional US.

bq --location=US cp -f mydataset.mytable,mydataset.mytable2 myotherproject:myotherdataset.mytable

Entrez la commande suivante pour copier myproject:mydataset.mytable et myproject:mydataset.mytable2 et renvoyer une erreur si l'ensemble de données de destination contient une table portant le même nom. L'ensemble de données de destination se trouve dans myotherproject. Le raccourci -n permet d'éviter d'écraser une table portant le même nom. Tous les ensembles de données ont été créés dans l'emplacement multirégional US.

bq --location=US cp -n myproject:mydataset.mytable,myproject:mydataset.mytable2 myotherproject:myotherdataset.mytable

Entrez la commande suivante pour copier mydataset.mytable et mydataset.mytable2 et pour ajouter les données à une table de destination portant le même nom. L'ensemble de données source est dans votre projet par défaut. L'ensemble de données de destination se trouve dans myotherproject. Le raccourci -a est utilisé pour ajouter à la table de destination. Tous les ensembles de données ont été créés dans l'emplacement multirégional US.

bq --location=US cp -a mydataset.mytable,mydataset.mytable2 myotherproject:myotherdataset.mytable

Entrez la commande suivante pour copier mydataset.mytable et mydataset.mytable2 dans mydataset2.tablecopy. Tous les ensembles de données sont dans votre projet par défaut et ont été créés dans la région asia-northeast1.

bq --location=asia-northeast1 cp mydataset.mytable,mydataset.mytable2 mydataset2.tablecopy

API

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

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

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le 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 Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
dataset := client.Dataset(datasetID)

srcTableIDs := []string{"table1", "table2"}
var tableRefs []*bigquery.Table
for _, v := range srcTableIDs {
	tableRefs = append(tableRefs, dataset.Table(v))
}
copier := dataset.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
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

TableId destinationTable = TableId.of(datasetId, destinationTableId);
CopyJobConfiguration configuration =
    CopyJobConfiguration.newBuilder(
        destinationTable,
        Arrays.asList(
            TableId.of(datasetId, "table1"),
            TableId.of(datasetId, "table2")))
    .build();

// Copy the tables.
Job job = bigquery.create(JobInfo.of(configuration));
job = job.waitFor();

// Check the table
StandardTableDefinition table = bigquery.getTable(destinationTable).getDefinition();
System.out.println("State: " + job.getStatus().getState());
System.out.printf("Copied %d rows.\n", table.getNumRows());

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# source_dataset_id = 'my_source_dataset'
# dest_dataset_id = 'my_destination_dataset'

table1_ref = client.dataset(source_dataset_id).table('table1')
table2_ref = client.dataset(source_dataset_id).table('table2')
dest_table_ref = client.dataset(dest_dataset_id).table('destination_table')

job = client.copy_table(
    [table1_ref, table2_ref],
    dest_table_ref,
    # Location must match that of the source and destination tables.
    location='US')  # API request
job.result()  # Waits for job to complete.

assert job.state == 'DONE'
dest_table = client.get_table(dest_table_ref)  # API request
assert dest_table.num_rows > 0

Supprimer des tables

Vous pouvez supprimer une table à l'aide des méthodes suivantes :

  • Utilisation de la console GCP ou de l'interface utilisateur Web classique de BigQuery
  • Utilisation de la commande bq rm de l'outil de ligne de commande
  • Appel de la méthode d'API tables.delete

Actuellement, vous ne pouvez supprimer qu'une table à la fois.

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 la date et l'heure d'expiration lorsque vous créez la table.

Autorisations requises

Pour supprimer une table, vous devez disposer d'un accès OWNER au niveau de l'ensemble de données ou d'un rôle IAM au niveau du projet qui inclut les autorisations bigquery.tables.delete. Les rôles IAM prédéfinis au niveau du projet incluent les autorisations bigquery.tables.delete :

Les utilisateurs auxquels est attribué un rôle prédéfini au niveau du projet peuvent supprimer des tables dans n'importe quel ensemble de données du projet. Les utilisateurs auxquels sont attribuées des autorisations OWNER au niveau de l'ensemble de données peuvent supprimer des tables uniquement dans cet ensemble de données.

Et comme le rôle bigquery.user dispose d'autorisations bigquery.datasets.create, un utilisateur ayant un rôle bigquery.user peut supprimer les tables des ensembles de données qu'il crée. Lorsqu'un utilisateur détenant le rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à celui-ci. L'accès OWNER à un ensemble de données confère à l'utilisateur un contrôle total sur l'ensemble de données et toutes les tables qu'il contient.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la section Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

Supprimer une table

Pour supprimer une table :

Interface utilisateur classique

  1. Cliquez sur l'icône représentant une flèche vers le bas flèche vers le bas située à côté du nom de votre table dans la barre de navigation, puis sur Supprimer la table.

  2. Lorsque vous y êtes invité, cliquez sur OK pour confirmer.

Ligne de commande

Utilisez la commande bq rm avec l'indicateur --table (ou le raccourci -t) pour supprimer une table. Lorsque vous utilisez la CLI pour supprimer une table, vous devez confirmer l'action. Vous pouvez utiliser l'indicateur --force (ou le raccourci -f) pour passer 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 au format suivant : [PROJECT_ID]:[DATASET].

bq rm -f -t [PROJECT_ID]:[DATASET].[TABLE]

Où :

  • [PROJECT_ID] est l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données contenant la table.
  • [TABLE] est le nom de la table que vous supprimez.

Exemples :

Entrez la commande suivante pour supprimer mytable de mydataset. mydataset se trouve dans votre projet par défaut.

bq rm -t mydataset.mytable

Entrez la commande suivante pour supprimer mytable de mydataset. mydataset se trouve dans myotherproject, pas dans votre projet par défaut.

bq rm -t myotherproject:mydataset.mytable

Entrez la commande suivante pour supprimer mytable de mydataset. mydataset se trouve dans votre projet par défaut. La commande se sert du raccourci -f pour contourner la confirmation.

bq rm -f -t mydataset.mytable

API

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

C#

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour C# dans le 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 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

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le 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 Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
table := client.Dataset(datasetID).Table(tableID)
if err := table.Delete(ctx); err != nil {
	return err
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

TableId tableId = TableId.of(projectId, datasetName, tableName);
boolean deleted = bigquery.delete(tableId);
if (deleted) {
  // the table was deleted
} else {
  // the table was not found
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Node.js dans le 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 Node.js.

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

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

// Creates a client
const bigquery = new BigQuery({projectId});

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

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

PHP

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour PHP dans le 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 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

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'
# table_id = 'my_table'

table_ref = client.dataset(dataset_id).table(table_id)
client.delete_table(table_ref)  # API request

print('Table {}:{} deleted.'.format(dataset_id, table_id))

Ruby

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Ruby dans le 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 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 une table supprimée

Vous pouvez restaurer une table dans les 2 jours suivant sa suppression. En tirant parti de la fonctionnalité snapshot decorator (décor d'instantané), il est possible de référencer une table avant l'événement de suppression, puis de la copier. Mais attention, cette méthode pour créer une référence comporte deux exceptions majeures :

  • Vous ne pouvez pas référencer une table supprimée si une table portant le même ID dans l'ensemble de données a été créée après l'heure de suppression.

  • Vous ne pouvez pas référencer une table supprimée si l'ensemble de données encapsulant a également été supprimé/recréé depuis l'événement de suppression de la table.

CLI

Pour annuler la suppression d'une table avec l'ancien SQL, utilisez le snapshot decorator (décor d'instantané) @<time>. Tout d'abord, déterminez un horodatage UNIX (en millisecondes) lorsque la table existait. Ensuite, copiez la table à cet horodatage dans une nouvelle table. La nouvelle table doit avoir un nom différent de celui de la table supprimée.

Par exemple, entrez la commande suivante pour mydataset.mytable copier au moment 1418864998000 dans une nouvelle table mydataset.newtable.

Spécifiez l'indicateur --location et définissez la valeur correspondant à votre emplacement.

bq --location = [LOCATION] cp mydataset.mytable@1418864998000 mydataset.newtable

Pour plus d'informations, consultez Décors de tables dans l'ancien SQL.

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")

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
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

// String datasetId = "my_dataset";
String tableId = "oops_undelete_me";

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

// "Accidentally" delete the table.
bigquery.delete(TableId.of(datasetId, tableId));

// Construct the restore-from tableID using a snapshot decorator.
String snapshotTableId = String.format("%s@%d", tableId, snapTime);
// Choose a new table ID for the recovered table data.
String recoverTableId = String.format("%s_recovered", tableId);

// Construct and run a copy job.
CopyJobConfiguration configuration =
    CopyJobConfiguration.newBuilder(
        TableId.of(datasetId, recoverTableId),
        TableId.of(datasetId, snapshotTableId))
    .build();
Job job = bigquery.create(JobInfo.of(configuration));
job = job.waitFor();

// Check the table
StandardTableDefinition table = bigquery.getTable(
        TableId.of(datasetId, recoverTableId)).getDefinition();
System.out.println("State: " + job.getStatus().getState());
System.out.printf("Recovered %d rows.\n", table.getNumRows());

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# TODO(developer): Uncomment the lines below and replace with your values.
# import time
# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'  # Replace with your dataset ID.
# table_id = 'my_table'      # Replace with your table ID.

table_ref = client.dataset(dataset_id).table(table_id)

# 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_ref)  # API request

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

# Choose a new table ID for the recovered table data.
recovered_table_id = '{}_recovered'.format(table_id)
dest_table_ref = client.dataset(dataset_id).table(recovered_table_id)

# Construct and run a copy job.
job = client.copy_table(
    source_table_ref,
    dest_table_ref,
    # Location must match that of the source and destination tables.
    location='US')  # API request

job.result()  # Waits for job to complete.

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

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.