Se usó la API de Cloud Translation para traducir esta página.

Accede a los datos históricos

BigQuery te permite consultar y restablecer los datos almacenados en BigQuery que se modificaron o borraron dentro de tu ventana de viaje en el tiempo.

Consulta datos de momentos determinados

Puedes consultar los datos históricos de una tabla desde cualquier momento dentro del período de viaje con una cláusula FOR SYSTEM_TIME AS OF. Esta cláusula usa una expresión de marca de tiempo constante y hace referencia a la versión de la tabla que era la más reciente en esa marca de tiempo. La tabla debe estar almacenada en BigQuery, no puede ser una tabla externa. No existe un límite para el tamaño de la tabla cuando se usa SYSTEM_TIME AS OF.

Por ejemplo, la siguiente consulta muestra una versión histórica de la tabla de una hora antes:

SELECT *
FROM `mydataset.mytable`
  FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR);

Si la marca de tiempo especifica un período anterior al período de viaje o antes de que se cree la tabla, la consulta fallará y mostrará un error como el siguiente:

Invalid snapshot time 1601168925462 for table
myproject:mydataset.table1@1601168925462. Cannot read before 1601573410026.

Después de reemplazar una tabla existente con la sentencia CREATE OR REPLACE TABLE, puedes usar FOR SYSTEM_TIME AS OF para consultar la versión anterior de la tabla.

Si se borró la tabla, falla la consulta y muestra un error como el siguiente:

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

Restablece la versión de una tabla de un momento determinado

Para restablecer una tabla desde los datos históricos, puedes copiar los datos históricos en una tabla nueva. La copia de datos históricos funciona incluso si la tabla se borró o caducó, siempre que restablezcas la tabla dentro de la duración del período de viaje en el tiempo.

Cuando restableces una tabla a partir de datos históricos, las etiquetas de la tabla de origen no se copian en la tabla de destino. La información de partición de la tabla tampoco se copia en la tabla de destino. Para volver a crear el esquema de partición de la tabla original, puedes ver la solicitud de creación de la tabla inicial en Cloud Logging y usar esa información para particionar la tabla restaurada.

Puedes restablecer una tabla que se haya borrado, pero que aún se encuentre dentro del período. Para ello, copia la tabla en una tabla nueva con el decorador de tiempo @<time>. No puedes consultar una tabla borrada, incluso si usas un decorador de tiempo. Primero debes restablecerlo.

Usa la siguiente sintaxis con el decorador de tiempo @<time>:

tableid@TIME en el que TIME es la cantidad de milisegundos transcurridos desde la época UNIX.
tableid@-TIME_OFFSET en el que TIME_OFFSET es la compensación relativa desde la hora actual, en milisegundos.
tableid@0: Especifica los datos históricos más antiguos disponibles.

Para restablecer una tabla, elige una de las siguientes opciones:

Console

No puedes recuperar una tabla con la Google Cloud consola.

bq

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.
Para restablecer una tabla, primero determina una marca de tiempo UNIX de cuando existió la tabla (en milisegundos). Puedes usar el comando date de Linux para generar la marca de tiempo de Unix a partir de un valor de marca de tiempo normal:
```
date -d '2023-08-04 16:00:34.456789Z' +%s000
```
Luego, usa el comando bq copy con el decorador de viajes en el tiempo @<time> para realizar la operación de copia de tabla.

Por ejemplo, ingresa el siguiente comando para copiar la tabla mydataset.mytable en el momento 1418864998000 en una nueva tabla mydataset.newtable.
```
bq cp mydataset.mytable@1418864998000 mydataset.newtable
```
Opcional: Proporciona la marca --location y configura el valor en tu ubicación.

También puedes especificar un desplazamiento relativo. En el siguiente ejemplo, se copia la versión de una tabla de hace una hora atrás:
```
bq cp mydataset.mytable@-3600000 mydataset.newtable
```
Nota: Si intentas recuperar datos antes del período de viaje en el tiempo o de un momento anterior a la creación de la tabla, recibirás un error Invalid time travel timestamp. Para obtener más información, consulta Soluciona problemas de recuperación de tablas.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 prevés que quieres restablecer una tabla más tarde de lo que permite el período de viaje en el tiempo, crea una instantánea de la tabla. Para obtener más información, consulta Introducción a las instantáneas de tablas.

No puedes restablecer una vista lógica directamente. Para obtener más información, consulta Cómo restablecer una vista.

¿Qué sigue?

Obtén más información sobre las instantáneas de tablas.
Obtén más información sobre la retención de datos con viaje en el tiempo y seguridad ante fallas.
Obtén más información para administrar tablas.