Restaurer les tables supprimées

Ce document explique comment restaurer (ou annuler la suppression) d'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 période temporelle écoulée, BigQuery fournit une période de sécurité pendant laquelle les données supprimées sont automatiquement conservées pendant sept jours supplémentaires. Une fois la période de sécurité écoulée, 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 via des rôles personnalisés ou d'autres rôles prédéfinis.

Restaurer une table

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 de l'historique 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, 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 afficher la requête 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 la restaurer.

Utilisez la syntaxe suivante avec le décorateur d'heure @<time> :

  • tableid@TIME où TIME correspond au 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 Google Cloud console.

bq

  1. Dans la Google Cloud console, activez Cloud Shell.

    Activer Cloud Shell

    En bas de la fenêtre de la Google Cloud console, 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.

  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 bq copy commande avec le @<time> décorateur de fonctionnalité temporelle 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

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.

Identifier le moment où une table a été supprimée

Utilisez le filtre suivant dans l'explorateur de journaux de la Google Cloud console pour identifier l'entrée d'audit qui indique l'expiration ou la suppression d'une table spécifiée :

resource.type="bigquery_resource"
protoPayload.resourceName="projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID"
(protoPayload.methodName="google.cloud.bigquery.v2.TableService.DeleteTable" OR protoPayload.methodName="tableservice.delete" OR protoPayload.serviceData.jobCompletedEvent.job.jobConfiguration.query.statementType="DROP_TABLE" OR protoPayload.methodName="InternalTableExpired")

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet.
  • DATASET_ID : ID de l'ensemble de données contenant la table.
  • TABLE_ID : ID de la table supprimée.

Vous pouvez également utiliser le filtre suivant pour rechercher l'expiration ou la suppression de l'ensemble de données contenant la table :

resource.type="bigquery_dataset"
protoPayload.resourceName="projects/PROJECT_ID/datasets/DATASET_ID"
(protoPayload.methodName="google.cloud.bigquery.v2.DatasetService.DeleteDataset" OR protoPayload.methodName="datasetservice.delete")

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet.
  • DATASET_ID : ID de l'ensemble de données contenant la table.

Identifier la cause de la suppression d'une table

Vous pouvez utiliser la INFORMATION_SCHEMA.TABLE_STORAGE vue pour déterminer comment une table a été supprimée.

La vue INFORMATION_SCHEMA.TABLE_STORAGE contient des informations sur les tables actuelles et les tables supprimées pendant la fenêtre temporelle. Si une table a été supprimée, la colonne table_deletion_time contient l'horodatage de la suppression, et la colonne table_deletion_reason contient la méthode de suppression.

Pour déterminer la raison pour laquelle une table a été supprimée, interrogez la vue INFORMATION_SCHEMA.TABLE_STORAGE :

SELECT
  table_name,
  deleted,
  table_deletion_time,
  table_deletion_reason
FROM
  `PROJECT_ID`.`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE
WHERE
  table_schema = "DATASET_ID"
  AND table_name = "TABLE_ID"

Remplacez les variables suivantes :

  • PROJECT_ID : ID du projet.
  • REGION : région de l'ensemble de données contenant la table.
  • DATASET_ID : ID de l'ensemble de données contenant la table.
  • TABLE_ID : ID de la table supprimée.

La colonne table_deletion_reason explique pourquoi la table a été supprimée :

  • TABLE_EXPIRATION : la table a été supprimée après l'heure d'expiration définie.
  • DATASET_DELETION : l'ensemble de données auquel appartenait la table a été supprimé par un utilisateur.
  • USER_DELETED : la table a été supprimée par un utilisateur.

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

Interroger la table supprimée à l'aide d'un horodatage antérieur

Vous ne pouvez pas restaurer les données de la table en interrogeant une table supprimée dans le passé à l'aide d'un décorateur d'horodatage ou en utilisant FOR SYSTEM_TIME AS OF pour enregistrer le résultat dans une table de destination. L'utilisation de l'une 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 les étapes décrites dans Restaurer une table.

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

Lorsque vous tentez d'exécuter la commande de copie à partir de Google Cloud Shell, vous pouvez rencontrer une erreur semblable à la suivante :

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

L'utilisation de Cloud Shell à partir de la Google Cloud console avec VPC SC n'est pas compatible, 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 Cloud Shell et connectez-vous à celui-ci en local avec Google Cloud CLI.

Erreur : Latest categories are incompatible with schema

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

Latest categories are incompatible with schema at TIMESTAMP

Cette erreur peut avoir plusieurs causes :

  • Le schéma de la table de destination est différent de celui de la table d'origine (les colonnes supplémentaires sont autorisées tant qu'aucun tag de stratégie au niveau des colonnes n'y est associé).
  • Les tags de stratégie au niveau des colonnes de la table de destination sont configurés différemment de ceux de la table source.

Pour résoudre cette erreur :

  1. Assurez-vous que le schéma de la table de destination est identique, qu'aucune des colonnes de la table d'origine ne manque dans la table de destination et que les colonnes sont dans le même ordre dans les deux tables.
  2. Supprimez tous les tags de 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 à partir de 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 antérieur à la fenêtre temporelle ou avant la création de la table. Cette fonctionnalité n'est pas disponible. Le message d'erreur contient l'horodatage le plus récent qui peut être utilisé pour lire les données de la table. Utilisez l'horodatage 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 la table à CURRENT_TIMESTAMP - PROVIDED TIMESTAMP. Cette valeur est normalement un horodatage 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 table et utilisez le signe - de manière appropriée.

Vues matérialisées

Vous ne pouvez pas restaurer directement une vue matérialisée supprimée. Si vous supprimez une vue matérialisée, vous devez la recréer.

Si vous supprimez une table qui est une table de base pour une vue matérialisée, la vue matérialisée ne peut plus être interrogée ni actualisée. Si vous restaurez la table de base en suivant les étapes décrites dans Restaurer une table, vous devez également recréer toutes les vues matérialisées qui utilisent cette table.

Tables externes

Vous ne pouvez pas restaurer directement une table externe supprimée. Si vous supprimez une table externe, vous devez la recréer. Le processus de recréation nécessite de connaître la définition de la table d'origine, et plus particulièrement les éléments suivants :

  • Le schéma de la table
  • Les URI sources pointant vers les données externes
  • Le format des données externes

Vous pouvez obtenir ces informations à partir de Cloud Logging en recherchant l'entrée de journal de création de table. Vous pouvez également essayer d'obtenir les URI en interrogeant la INFORMATION_SCHEMA.TABLE_OPTIONS vue si la table vient d'être supprimée.

La suppression de la table externe n'entraîne pas la suppression des données sous-jacentes.

Étape suivante