Ripristinare tabelle eliminate

Questo documento descrive come ripristinare (o recuperare) una tabella eliminata in BigQuery. Puoi ripristinare una tabella eliminata entro la finestra di spostamento cronologico specificata per il set di dati, incluse le eliminazioni esplicite e quelle implicite dovute alla scadenza della tabella. Puoi anche configurare la finestra di time travel.

Per informazioni su come ripristinare un intero set di dati o snapshot eliminato, consulta le seguenti risorse:

La finestra di spostamento cronologico può avere una durata compresa tra due e sette giorni. Una volta trascorso il periodo di time travel, BigQuery fornisce un periodo di sicurezza in cui i dati eliminati vengono conservati automaticamente per altri sette giorni. Una volta trascorso il periodo di sicurezza, non è possibile ripristinare una tabella con nessun metodo, inclusa l'apertura di unaticket di assistenzaa.

Prima di iniziare

Assicurati di disporre delle autorizzazioni IAM (Identity and Access Management) necessarie per ripristinare una tabella eliminata.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per ripristinare una tabella eliminata, chiedi all'amministratore di concederti il ruolo IAM BigQuery User (roles/bigquery.user) sul progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Ripristinare una tabella

Puoi ripristinare una tabella dai dati storici copiandoli in una nuova tabella. La copia dei dati storici funziona anche se la tabella è stata eliminata o è scaduta, a condizione che la ripristini entro la durata della finestra di Time Travel.

Quando ripristini una tabella dai dati storici, i tag della tabella di origine non vengono copiati nella tabella di destinazione. Anche le informazioni sul partizionamento della tabella non vengono copiate nella tabella di destinazione. Per ricreare lo schema di partizionamento della tabella originale, puoi visualizzare la richiesta di creazione della tabella iniziale in Cloud Logging e utilizzare queste informazioni per partizionare la tabella ripristinata.

Puoi ripristinare una tabella che è stata eliminata ma che rientra ancora nella finestra di Time Travel copiandola in una nuova tabella utilizzando il decoratore temporale @<time>. Non puoi eseguire query su una tabella eliminata, anche se utilizzi un decoratore temporale. Devi prima ripristinarlo.

Utilizza la seguente sintassi con il decoratore temporale @<time>:

  • tableid@TIME dove TIME è il numero di millisecondi trascorsi dall'epoca Unix.
  • tableid@-TIME_OFFSET dove TIME_OFFSET è l'offset relativo rispetto all'ora corrente, in millisecondi.
  • tableid@0: specifica i dati storici meno recenti disponibili.

Per ripristinare una tabella, seleziona una delle seguenti opzioni:

Console

Non puoi recuperare una tabella utilizzando 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. Per ripristinare una tabella, determina innanzitutto un timestamp UNIX di quando la tabella esisteva (in millisecondi). Puoi utilizzare il comando Linux date per generare il timestamp Unix da un valore di timestamp normale:

    date -d '2023-08-04 16:00:34.456789Z' +%s000

  3. Quindi, utilizza il comando bq copy con il decoratore di spostamento nel tempo @<time> per eseguire l'operazione di copia della tabella.

    Ad esempio, inserisci il seguente comando per copiare la tabella mydataset.mytable all'ora 1418864998000 in una nuova tabella mydataset.newtable.

    bq cp mydataset.mytable@1418864998000 mydataset.newtable

    (Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

    Puoi anche specificare un offset relativo. Il seguente esempio copia la versione di una tabella di un'ora fa:

    bq cp mydataset.mytable@-3600000 mydataset.newtable

    4. Vai

    Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Go.

    Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client. 

    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

    Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

    Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client. 

    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

    Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

    Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client. 

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

    Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

    Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client. 

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

Se prevedi di voler ripristinare una tabella in un momento successivo a quello consentito dalla finestra di Time Travel, crea uno snapshot della tabella. Per saperne di più, consulta la pagina Introduzione agli snapshot delle tabelle.

Non puoi ripristinare direttamente una visualizzazione logica. Per ulteriori informazioni, vedi Ripristinare una visualizzazione.

Risolvere i problemi di recupero della tabella

Esecuzione di query sulla tabella eliminata utilizzando un timestamp nel passato

Non puoi ripristinare i dati della tabella eseguendo query su una tabella eliminata in passato utilizzando un decoratore timestamp o utilizzando FOR SYSTEM_TIME AS OF per salvare il risultato in una tabella di destinazione. L'utilizzo di uno di questi metodi genera il seguente errore:

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

Per copiare la tabella, segui i passaggi descritti in Ripristinare una tabella.

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

Quando tenti di eseguire il comando di copia da Google Cloud Shell, potresti riscontrare un errore come il seguente:

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

L'utilizzo di Cloud Shell dalla console Google Cloud con Controlli di servizio VPC non è supportato, perché viene trattato come una richiesta al di fuori dei perimetri di servizio e l'accesso ai dati protetti da Controlli di servizio VPC viene negato. Per risolvere questo problema, avvia e connettiti a Cloud Shell localmente con Google Cloud CLI.

Errore: Latest categories are incompatible with schema

Se esegui il comando di copia da Google Cloud Shell, potresti ricevere un errore come il seguente:

Latest categories are incompatible with schema at TIMESTAMP

Esistono diverse possibili cause di questo errore:

Per risolvere questo errore:

  1. Assicurati che lo schema della tabella di destinazione sia identico e che nella tabella di destinazione non manchi nessuna delle colonne della tabella originale.
  2. Rimuovi dalla tabella di destinazione tutti i tag di criteri a livello di colonna che non sono presenti nello schema della tabella originale.

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

Se esegui il comando bq copy da Google Cloud Shell, potresti ricevere un errore simile al seguente:

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

Questo errore indica che stai tentando di recuperare i dati dallo stato della tabella prima della finestra di Time Travel o prima della creazione della tabella. Questa opzione non è supportata. Il messaggio di errore contiene il timestamp più recente che può essere utilizzato per leggere i dati della tabella. Utilizza il timestamp dell'errore nel comando bq copy.

Questo errore può verificarsi anche quando fornisci un valore timestamp negativo, ad esempio TABLE@-1744963620000. Utilizza invece un offset temporale che può essere utilizzato con il segno -.

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

Questo messaggio di errore indica che il comando bq cp contiene un valore timestamp negativo come offset e che hai tentato di leggere la tabella in CURRENT_TIMESTAMP - PROVIDED TIMESTAMP. Questo valore è normalmente un timestamp nel 1970. Per risolvere questo problema, verifica i valori di offset o timestamp quando imposti il valore del decoratore della tabella e utilizza il segno - in modo appropriato.

Passaggi successivi