Acessar dados históricos

Com o BigQuery, é possível consultar e restaurar dados armazenados no BigQuery que foram alterados ou excluídos na janela de viagem no tempo.

Consultar dados em um momento específico

É possível consultar os dados históricos de uma tabela a qualquer momento na janela de viagem no tempo usando uma cláusula FOR SYSTEM_TIME AS OF. Essa cláusula usa uma expressão de carimbo de data/hora constante e faz referência à versão da tabela que estava sendo atualizada no carimbo de data/hora. A tabela precisa ser armazenada no BigQuery; não pode ser uma tabela externa. Não há limite no tamanho da tabela quandoSYSTEM_TIME AS OF é usado.

Por exemplo, a seguinte consulta retorna uma versão histórica de uma hora atrás:

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

Se o carimbo de data/hora especificar um horário anterior à janela de viagem no tempo ou antes da criação da tabela, a consulta falhará e retornará um erro como o seguinte:

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

Depois de substituir uma tabela atual usando a instrução CREATE OR REPLACE TABLE, use FOR SYSTEM_TIME AS OF para consultar a versão anterior da tabela.

Se a tabela foi excluída, a consulta falhará e retornará um erro como este:

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

Restaurar uma tabela de um momento

Para restaurar uma tabela de dados históricos, copie-os para uma nova tabela. A cópia de dados históricos funciona mesmo que a tabela tenha sido excluída ou tenha expirado, desde que você restaure a tabela dentro do período da janela de viagem no tempo.

Ao restaurar uma tabela de dados históricos, as tags da tabela de origem não são copiadas para a tabela de destino. As informações de particionamento da tabela também não são copiadas para a tabela de destino. Para recriar o esquema de particionamento da tabela original, consulte a solicitação inicial de criação de tabela no Cloud Logging e use essas informações para particionar a tabela restaurada.

É possível restaurar uma tabela que foi excluída, mas ainda está dentro do período de viagem copiando-a para uma nova tabela usando o decorador de tempo @<time>. Não é possível consultar uma tabela excluída, mesmo que você use um decorador de tempo. Primeiro, restaure o dispositivo.

Use a seguinte sintaxe com o decorador de tempo @<time>:

  • tableid@TIME em que TIME é o número de milissegundos desde a época do Unix.
  • tableid@-TIME_OFFSET, em que TIME_OFFSET é o deslocamento relativo do horário atual, em milissegundos.
  • tableid@0: especifica os dados históricos mais antigos disponíveis.

Para restaurar uma tabela, selecione uma das seguintes opções:

Console

Não é possível cancelar a exclusão de uma tabela usando o console do 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. Para restaurar uma tabela, primeiro determine um carimbo de data/hora UNIX de quando ela existia (em milissegundos). É possível usar o comando date do Linux para gerar o carimbo de data/hora Unix a partir de um valor de carimbo de data/hora normal:

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

  3. Em seguida, use o comando bq copy com o decorador de viagem no tempo @<time> para executar a operação de cópia da tabela.

    Por exemplo, digite o seguinte comando para copiar a tabela mydataset.mytable no momento 1418864998000 para uma nova tabela mydataset.newtable.

    bq cp mydataset.mytable@1418864998000 mydataset.newtable

    Opcional: forneça a sinalização --location e defina o valor do local.

    Também é possível especificar um deslocamento relativo. O exemplo a seguir copia a versão de uma tabela de uma hora atrás:

    bq cp mydataset.mytable@-3600000 mydataset.newtable

    4. Go

    Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.

    Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de 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 testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

    Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de 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 testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Node.js.

    Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de 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 testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.

    Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de 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)
)

Se você antecipar que talvez queira restaurar uma tabela mais tarde diferente da permitida pelo período de viagem, crie um snapshot da tabela. Para mais informações, consulte Introdução aos snapshots da tabela.

Não é possível restaurar uma visualização lógica diretamente. Para mais informações, consulte Restaurar uma visualização.

A seguir