גישה לנתונים היסטוריים

ב-BigQuery אתם יכולים לשלוח שאילתות ולשחזר נתונים שמאוחסנים ב-BigQuery, ששונו או נמחקו בחלון המסע בזמן. הגישה לנתונים ההיסטוריים האלה מאפשרת לכם לשחזר מחיקות שבוצעו בטעות, או לנתח את המצב המדויק של הנתונים בנקודת זמן ספציפית בעבר, בלי שתצטרכו לתחזק גיבויים נפרדים.

שליחת שאילתות על נתונים בנקודת זמן מסוימת

אתם יכולים לשלוח שאילתה על הנתונים ההיסטוריים של טבלה מכל נקודת זמן בחלון הזמן של המסע בזמן, באמצעות משפט FOR SYSTEM_TIME AS OF. הפסוקית הזו מקבלת ביטוי קבוע של חותמת זמן ומפנה לגרסה של הטבלה שהייתה עדכנית באותה חותמת זמן. הטבלה חייבת להיות מאוחסנת ב-BigQuery, ולא יכולה להיות טבלה חיצונית. אין הגבלה על גודל הטבלה כשמשתמשים ב-SYSTEM_TIME AS OF.

לדוגמה, השאילתה הבאה מחזירה גרסה היסטורית של הטבלה מלפני שעה:

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

הערה: הסעיף FOR SYSTEM_TIME AS OF נתמך ב-GoogleSQL. ב-SQL מדור קודם, מעצבי זמן מספקים פונקציונליות מקבילה.

אם חותמת הזמן מציינת זמן שלפני חלון הזמן של Time Travel או לפני שהטבלה נוצרה, השאילתה נכשלת ומוחזרת שגיאה כמו זו:

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

אחרי שמחליפים טבלה קיימת באמצעות ההצהרה CREATE OR REPLACE TABLE, אפשר להשתמש ב-FOR SYSTEM_TIME AS OF כדי לשלוח שאילתה לגרסה הקודמת של הטבלה.

אם הטבלה נמחקה, אי אפשר לשלוח שאילתה על הנתונים ההיסטוריים שלה ישירות באמצעות FOR SYSTEM_TIME AS OF. השאילתה נכשלת ומוחזרת שגיאה כמו זו:

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

כדי לגשת לנתונים היסטוריים של טבלה שנמחקה, צריך לשחזר את הטבלה מנקודת זמן.

שחזור טבלה מנקודת זמן מסוימת

כדי לשחזר טבלה מנתונים היסטוריים, אתם יכולים להעתיק את הנתונים ההיסטוריים לטבלה חדשה. העתקת נתונים היסטוריים פועלת גם אם הטבלה נמחקה או פג תוקפה, כל עוד משחזרים את הטבלה במהלך חלון הזמן של Time Travel.

כשמשחזרים טבלה מנתונים היסטוריים, התגים מטבלת המקור לא מועתקים לטבלת היעד. גם פרטי החלוקה למחיצות של הטבלה לא מועתקים לטבלת היעד. כדי ליצור מחדש את סכימת החלוקה למחיצות של הטבלה המקורית, אפשר להציג את הבקשה הראשונית ליצירת הטבלה ב-Cloud Logging ולהשתמש במידע הזה כדי לחלק למחיצות את הטבלה ששוחזרה.

אפשר לשחזר רק טבלה שלמה. אי אפשר לשחזר מחיצות נפרדות. לדוגמה, אי אפשר להעתיק מחיצה באמצעות מעטר מחיצה כמו bq cp mydataset.mytable$20260712@1418864998000 mydataset.mytable_restored.

כדי לשחזר טבלה שנמחקה אבל עדיין נמצאת בחלון הזמן של Time Travel, אתם יכולים להעתיק אותה לטבלה חדשה באמצעות מעצב הזמן @<time>. אי אפשר לשלוח שאילתה לטבלה שנמחקה, גם אם משתמשים במעטר זמן. קודם צריך לשחזר אותו.

משתמשים בתחביר הבא עם מעצב הזמן @<time>:

• ‫tableid@TIME, כאשר TIME הוא מספר אלפיות השנייה מאז ראשית זמן יוניקס (Unix epoch).
• ‫tableid@-TIME_OFFSET כאשר TIME_OFFSET הוא ההיסט היחסי מהשעה הנוכחית, באלפיות השנייה.
• ‫tableid@0: מציין את הנתונים ההיסטוריים הכי ישנים שזמינים.

כדי לשחזר טבלה, בוחרים באחת מהאפשרויות הבאות:

המסוף

אי אפשר לבטל מחיקה של טבלה באמצעות מסוף Google Cloud .

BQ

1. מפעילים את Cloud Shell במסוף Google Cloud .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. כדי לשחזר טבלה, קודם צריך לקבוע חותמת זמן של UNIX למועד שבו הטבלה הייתה קיימת (באלפיות השנייה). אפשר להשתמש בפקודה date של Linux כדי ליצור את חותמת הזמן של Unix מערך רגיל של חותמת זמן:

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

3. לאחר מכן, משתמשים בפקודה bq copy עם מעצב המסע בזמן @<time> כדי לבצע את פעולת ההעתקה של הטבלה.

   לדוגמה, מזינים את הפקודה הבאה כדי להעתיק את הטבלה mydataset.mytable בזמן 1418864998000 לטבלה חדשה mydataset.newtable.

   bq cp mydataset.mytable@1418864998000 mydataset.newtable
   

   (אופציונלי) מציינים את הדגל --location ומגדירים את הערך למיקום שלכם.

   אפשר גם לציין היסט יחסי. בדוגמה הבאה, המערכת מעתיקה את הגרסה של הטבלה מלפני שעה:

   bq cp mydataset.mytable@-3600000 mydataset.newtable
   

   הערה: אם תנסו לשחזר נתונים לפני חלון הזמן של Time Travel או לפני שהטבלה נוצרה, תקבלו את השגיאה Invalid time travel timestamp. למידע נוסף, ראו פתרון בעיות בשחזור טבלאות.

המשך

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Go במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Go API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Java במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Node.js במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Node.js API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Python במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Python API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

אם אתם חושבים שתרצו לשחזר טבלה אחרי חלון הזמן של "המסע בזמן", צרו תמונת מצב של הטבלה. מידע נוסף זמין במאמר מבוא לתמונות מצב של טבלאות.

אי אפשר לשחזר תצוגה לוגית באופן ישיר. מידע נוסף זמין במאמר שחזור תצוגה.

הערה: אם מוחקים טבלה ויוצרים טבלה חדשה עם אותו שם, אפשר לשחזר את הנתונים מהטבלה המקורית שנמחקה באמצעות שחזור מערכת מנקודה מסוימת בזמן (PITR). חותמת הזמן חייבת לציין זמן שבו הטבלה המקורית הייתה קיימת.

המאמרים הבאים

• מידע נוסף על קובצי snapshot של טבלאות
• מידע נוסף על שמירת נתונים באמצעות Time Travel ו-Fail-safe
• מידע נוסף על ניהול טבלאות