Restaurer les tables supprimées

Ce document explique comment restaurer (ou récupérer) une table supprimée dans BigQuery. Vous pouvez restaurer une table supprimée 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 également configurer la fenêtre de fonctionnalité temporelle.

Pour savoir comment restaurer un ensemble de données ou un instantané supprimé, consultez les ressources suivantes :

La période temporelle peut durer entre deux et sept jours. Une fois la fenêtre de fonctionnalité temporelle expirée, BigQuery offre une période de sécurité pendant laquelle les données supprimées sont automatiquement conservées pendant sept jours supplémentaires. Une fois le délai de sécurité écoulé, il n'est plus possible de restaurer une table, quelle que soit la méthode utilisée, y compris pour ouvrir une demande d'assistance.

Avant de commencer

Assurez-vous de disposer des autorisations IAM (Identity and Access Management) nécessaires pour restaurer une table supprimée.

Rôles requis

Pour obtenir les autorisations nécessaires pour restaurer une table supprimée, demandez à votre administrateur de vous accorder le rôle IAM Utilisateur BigQuery (roles/bigquery.user) sur le projet. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

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

Restaurer un tableau

Vous pouvez restaurer une table à partir des données de l'historique en copiant les données de l'historique dans une nouvelle table. La copie des données historiques fonctionne même si la table a été supprimée ou a expiré, tant que vous la restaurez pendant la durée de la fenêtre de fonctionnalité temporelle.

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. Les informations de partitionnement de la table ne sont pas non plus copiées dans la table de destination. Pour recréer le schéma de partitionnement de la table d'origine, vous pouvez consulter la demande de création de table initiale dans Cloud Logging et utiliser ces informations pour partitionner la table restaurée.

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>. Vous ne pouvez pas interroger une table supprimée, même si vous utilisez un décorateur d'heure. Vous devez d'abord le restaurer.

Utilisez la syntaxe suivante avec le décorateur de temps @<time> :

  • tableid@TIME, où TIME est le nombre de millisecondes écoulées depuis l'époque Unix.
  • tableid@-TIME_OFFSET, où TIME_OFFSET est le décalage relatif par rapport à l'heure actuelle, en millisecondes.
  • tableid@0 : spécifie les données de l'historique les plus anciennes disponibles.

Pour restaurer une table, sélectionnez l'une des options suivantes :

Console

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

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

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

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

    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.

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

    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.

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

    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.

    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 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 page Présentation des instantanés de table.

Vous ne pouvez pas restaurer directement une vue logique. Pour en savoir plus, consultez Restaurer une vue.

Résoudre les problèmes de récupération de tables

Interroger la table supprimée à l'aide d'un code temporel passé

Vous ne pouvez pas restaurer les données d'une table en interrogeant une table supprimée dans le passé à l'aide d'un décorateur de code temporel ni en utilisant FOR SYSTEM_TIME AS OF pour enregistrer le résultat dans une table de destination. L'utilisation de l'une ou l'autre de ces méthodes génère l'erreur suivante :

Not found: Table myproject:mydataset.table was not found in location LOCATION

Pour copier la table, suivez plutôt la procédure décrite dans Restaurer une table.

Erreur : VPC Service Controls: Request is prohibited by organization's policy

Lorsque vous essayez d'exécuter la commande de copie depuis Google Cloud Shell, vous pouvez rencontrer une erreur semblable à celle-ci :

BigQuery error in cp operation: VPC Service Controls: Request is prohibited by organization's policy

L'utilisation de Cloud Shell depuis la console Google Cloud avec VPC-SC n'est pas prise en charge, car elle est traitée comme une requête en dehors des périmètres de service et l'accès aux données protégées par VPC Service Controls est refusé. Pour contourner ce problème, lancez et connectez-vous à Cloud Shell en local avec la Google Cloud CLI.

Erreur : Latest categories are incompatible with schema

Si vous exécutez la commande de copie depuis Google Cloud Shell, vous pouvez recevoir une erreur semblable à la suivante :

Latest categories are incompatible with schema at TIMESTAMP

Plusieurs raisons peuvent expliquer cette erreur :

Pour résoudre cette erreur :

  1. Assurez-vous que le schéma de la table de destination est identique et qu'aucune colonne de la table d'origine ne manque dans la table de destination.
  2. Supprimez tous les tags avec stratégie au niveau des colonnes de la table de destination qui ne figurent pas dans le schéma de la table d'origine.

Erreur : BigQuery error in cp operation: Invalid time travel timestamp

Si vous exécutez la commande bq copy depuis Google Cloud Shell, vous pouvez recevoir une erreur semblable à la suivante :

BigQuery error in cp operation: Invalid time travel timestamp 1744343690000 for
table PROJECT_ID:DATASET_ID.TABLE_ID@1744343690000.
Cannot read before 1744843691075

Cette erreur indique que vous essayez de récupérer des données à partir de l'état de la table avant la fenêtre de fonctionnalité temporelle ou avant la création de la table. Cette fonctionnalité n'est pas disponible. Le message d'erreur contient le dernier code temporel pouvant être utilisé pour lire les données du tableau. Utilisez le code temporel de l'erreur dans la commande bq copy.

Cette erreur peut également se produire lorsque vous fournissez une valeur d'horodatage négative, par exemple TABLE@-1744963620000. Utilisez plutôt un décalage temporel qui peut être utilisé avec le signe -.

BigQuery error in cp operation: Invalid time travel timestamp 584878816 for
table PROJECT_ID:DATASET_ID.TABLE_ID@584878816.
Cannot read before 1744843691075

Ce message d'erreur indique que la commande bq cp contient une valeur d'horodatage négative en tant que décalage et que vous avez tenté de lire le tableau à CURRENT_TIMESTAMP - PROVIDED TIMESTAMP. Cette valeur est normalement un code temporel en 1970. Pour contourner ce problème, vérifiez les valeurs de décalage ou d'horodatage lorsque vous définissez la valeur du décorateur de tableau et utilisez le signe - de manière appropriée.

Étapes suivantes