Snapshots für Backups und unveränderlichen Speicher¶

Snapshot¶

Ein Snapshot ist eine zeitpunktbezogene Sicherung eines Objekts.

• Das Objekt kann eine einzelne Tabelle, ein Schema oder eine ganze Datenbank sein.

• Ein bestimmter Snapshot kann durch eine eindeutige ID identifiziert werden, die von Snowflake generiert wurde.

• Ein Snapshot kann nicht geändert werden. Er kann jedoch gelöscht werden, und der Ablaufzeitraum des Snapshots kann geändert werden (es sei denn, es wird eine Aufbewahrungssperre angewendet).

Im täglichen Betrieb interagieren Sie selten mit einzelnen Snapshots. Stattdessen verwalten Sie die Snapshot-Sets, die sie enthalten. Sie erhalten zum Beispiel eine Liste der Snapshots, indem Sie den Befehl SHOW SNAPSHOTS IN SNAPSHOT SET ausführen. Sie erstellen einen neuen Snapshot, indem Sie einen Befehl ALTER SNAPSHOT SET ausführen.

Snapshot-Set¶

Ein Snapshot-Set ist ein Objekt auf Schemaebene, das einen Satz von Snapshots für eine bestimmte Datenbank, ein bestimmtes Schema oder eine bestimmte Tabelle enthält. Snowflake verfügt über SQL-Befehle zum CREATE, ALTER, DROP, SHOWund DESCRIBE von Snapshot-Sets.

Sie können mehrere Snapshot-Sets für dasselbe Objekt haben. Die Anzahl der Snapshot-Sets für dasselbe Objekt ist während der öffentlichen Vorschau begrenzt. Weitere Informationen dazu finden Sie unter Einschränkungen von Snapshots während des Zeitraums der öffentlichen Vorschau.

Der Lebenszyklus der Snapshots innerhalb eines Satzes wird durch eine optionale Snapshot-Richtlinie bestimmt, die Sie an das Snapshot-Set anhängen können. Sie können Snapshots auch manuell zu einem Snapshot-Set hinzufügen oder löschen. Ihre Möglichkeit, Snapshots zu löschen, wird durch andere Faktoren beeinflusst, insbesondere durch die Aufbewahrungssperre und gesetzliche Aufbewahrungsfrist.

Snapshot-Richtlinie¶

Eine Snapshot-Richtlinie ist ein Objekt auf Schemaebene, das die Einstellungen enthält, die den Lebenszyklus der Snapshots innerhalb eines Snapshot-Sets definieren. Zu diesen Einstellungen gehören Zeitplan, Ablauf und Aufbewahrungssperre.

• Der Zeitplan bestimmt, wann Snapshots erstellt werden. Der Zeitplan kann als Intervall in Minuten oder als Cron-Ausdruck definiert werden. Wenn der Zeitplan beispielsweise auf eine Stunde eingestellt ist, wird alle 60 Minuten ein Snapshot des Objekts erstellt.

• Die Ablaufzeit ist die Zeitspanne, für die der Snapshot gültig ist. Nach Ablauf eines Snapshots löscht Snowflake ihn automatisch, es sei denn, für diesen Snapshot gilt eine gesetzliche Aufbewahrungsfrist.

  Tipp

  Wenn für das Snapshot-Set keine Aufbewahrungssperre gilt und für den jeweiligen Snapshot keine rechtlichen Aufbewahrungsfristen gelten, können Sie den Snapshot vor dem Ende der Ablaufzeit manuell löschen. Sie können Snapshots nacheinander manuell löschen, immer beginnend mit dem ältesten Snapshot, für den keine gesetzliche Aufbewahrungsfrist gilt.

Jede Snapshot-Richtlinie muss eine oder beide Eigenschaften des Zeitplans und des Ablaufzeitraums haben. Sie können zum Beispiel eine Richtlinie mit einem Zeitplan und einer Ablauffrist erstellen und Snowflake das Erstellen und Entfernen der Snapshots in allen Snapshot-Sets überlassen, auf die diese Richtlinie angewendet wird. Alternativ können Sie eine Richtlinie mit einem Zeitplan und ohne Ablauffrist erstellen, wenn Sie das Entfernen älterer Snapshots selbst verwalten möchten. Sie können aber auch eine Richtlinie mit einer Ablauffrist, aber ohne Zeitplan erstellen und dann die Erstellung von Snapshots selbst verwalten. Sie können keine Richtlinie ohne Zeitplan und ohne Ablauffrist erstellen.

Wenn Sie eine Snapshot-Richtlinie mit einem Snapshot-Satz verknüpfen, können Sie dies tun, wenn Sie den Snapshot-Satz erstellen. Sie können die Richtlinie auch später anwenden. Sie können ebenfalls ein Snapshot-Set haben, das keine zugehörige Snapshot-Richtlinie hat. In diesem Fall steuern Sie manuell, wann neue Snapshots erstellt und alte Snapshots verfallen werden.

Sie können eine Snapshot-Richtlinie auf mehrere Snapshot-Sets anwenden. Wenn Sie eine Snapshot-Richtlinie ändern, wendet Snowflake die Änderungen auf alle Snapshot-Sets an, mit denen die Richtlinie verknüpft ist.

Aufbewahrungssperre¶

Eine Aufbewahrungssperre schützt einen Snapshot für die definierte Ablauffrist vor dem Löschen. Sie können einen Snapshot mit einer Aufbewahrungssperre für Backups zur Einhaltung gesetzlicher Bestimmungen und zur Cyber-Ausfallsicherheit verwenden. Die folgenden Einschränkungen gelten für ein Snapshot-Set mit Aufbewahrungssperre:

• Snapshots können von keiner Rolle gelöscht werden, auch nicht von der ACCOUNTADMIN-Rolle.

• Sie können die Ablauffrist des Snapshots nicht verkürzen, aber Sie können die Ablauffrist verlängern.

• Sie können ein Snapshot-Set nicht löschen, wenn noch nicht abgelaufene Snapshots im Set vorhanden sind.

• Sie können ein Schema, das ein Snapshot-Set mit nicht abgelaufenen Snapshots enthält, nicht löschen.

• Sie können eine Datenbank, die ein Snapshot-Set mit noch nicht abgelaufenen Snapshots enthält, nicht löschen.

• Sie können ein Konto, das eine Datenbank mit einem Snapshot-Set enthält, in dem noch nicht abgelaufene Snapshots vorhanden sind, nicht löschen.

Gesetzliche Aufbewahrungsfrist¶

Das Feature Gesetzliche Aufbewahrungsfrist von Snowflake-Snapshots verhindert, dass Snapshots überschrieben oder gelöscht werden. Auf diese Weise können Sie Snowflake-Datenbanken, -Schemas oder -Tabellen auf der Grundlage Ihrer eigenen rechtlichen Anforderungen erhalten.

Mit Snowflake können Sie für bestimmte Snapshots eine gesetzliche Aufbewahrungsfrist festlegen. Wenn ein Snowflake-Snapshot unter gesetzliche Aufbewahrungsfristen fällt, gelten die folgenden Bedingungen:

• Niemand kann den Snapshot ändern.

• Niemand kann den Snapshot löschen. Das gilt auch dann, wenn die Frist EXPIRE_AFTER_DAYS des Snapshots abgelaufen ist.

• Der Zugriff auf den Snapshot wird protokolliert und ist überprüfbar.

• Die gesetzliche Aufbewahrungsfrist kann im Gegensatz zu einer Aufbewahrungssperre von einem berechtigten Benutzer entfernt werden.

Überblick über den Lebenszyklus des Snapshots¶

Das folgende Diagramm zeigt, wie die Snowflake-Objekte, Snapshots, Snapshot-Sets und Snapshot-Richtlinien miteinander in Beziehung stehen. Das Diagramm enthält die einfachste Art von Snapshot: einen Snapshot für eine einzelne Tabelle. Jede Backup-Operation erstellt einen neuen Snapshot. Alle Snapshots für dieses bestimmte Objekt sind in einem Snapshot-Set zusammengefasst. Das automatische Hinzufügen und Entfernen von Snapshots im Snapshot-Set wird von der Snapshot-Richtlinie geregelt. Um die Informationen aus einem Snapshot wiederherzustellen, verwenden Sie einen CREATE-Befehl, um ein neues Objekt aus einem bestimmten Snapshot zu erstellen.

Einschränkungen von Snapshots während des Zeitraums der öffentlichen Vorschau¶

Die folgenden Beschränkungen können sich ändern, wenn das Snapshot-Feature allgemein verfügbar wird:

• Wenn Sie einen regelmäßigen Zeitplan für Snapshots einrichten, erlegt Snowflake eine maximale Aufbewahrungsfrist auf, die auf der Häufigkeit der geplanten Snapshots basiert. In einer Snapshot-Richtlinie ist die EXPIRE_AFTER_DAYS-Eigenschaft auf der Grundlage der zugehörigen SCHEDULE-Eigenschaft wie folgt beschränkt:

  • Snapshot-Richtlinien mit einer Häufigkeit von 60 bis 119 Minuten haben einen maximalen EXPIRE_AFTER_DAYS-Wert von 90.

  • Snapshot-Richtlinien mit einer Häufigkeit von 120 Minuten bis 23 Stunden und 59 Minuten haben einen maximalen EXPIRE_AFTER_DAYS-Wert von 180.

  • Snapshot-Richtlinien mit einer Häufigkeit von 24 Stunden oder mehr haben einen maximalen EXPIRE_AFTER_DAYS-Wert von 366.

  • Snapshot-Richtlinien ohne Zeitplan haben einen maximalen EXPIRE_AFTER_DAYS-Wert von 3653.

• Sie können maximal zwei Datenbank-Snapshot-Sets für eine bestimmte Datenbank erstellen. Ebenso können Sie maximal zwei Schema-Snapshot-Sets für ein bestimmtes Schema und zwei Tabellen-Snapshot-Sets für eine bestimmte Tabelle erstellen. Ein Objekt kann immer noch in mehr als zwei Snapshot-Sets vorkommen. Eine Tabelle kann zum Beispiel ein oder zwei zugeordnete Tabellen-Snapshot-Sets haben. Dieselbe Tabelle kann auch in einem oder zwei Schema-Snapshot-Sets und einem oder zwei Datenbank-Snapshot-Sets enthalten sein.

• Nachdem eine Snapshot-Richtlinie auf ein Snapshot-Set angewendet wurde, können Sie die Richtlinie nicht mehr aus diesem Snapshot-Set entfernen.

Referenzen von Tabellen auf andere Objekte¶

Objekte, wie z. B. Ansichten oder Funktionen, können im Snapshot auf Objekte außerhalb des Schemas oder der Datenbank verweisen. Um sicherzustellen, dass solche Referenzen nach der Wiederherstellung aus einem Snapshot weiterhin funktionieren, verwenden Sie eine der folgenden Strategien:

• Wenn sich die Tabellen und die anderen Objekte, auf die sie verweisen, alle in demselben Schema oder derselben Datenbank befinden, erstellen Sie ein Snapshot-Set für das gesamte Schema oder die gesamte Datenbank. Auf diese Weise stellt Snowflake alle verbundenen Objekte auf einmal wieder her, wenn Sie aus dem Snapshot wiederherstellen.

• Wenn Objekte in einem Snapshot-Set auf Objekte verweisen, die nicht im Snapshot-Set enthalten sind, sollten Sie beachten, dass bei Wiederherstellung eines Snapshots die Referenzen von den wiederhergestellten Objekten auf die ursprünglichen Objekte aus der anderen Datenbank oder dem anderen Schema verweisen. Wenn Sie diese anderen Objekte nach der Erstellung des Snapshots gelöscht oder deren Eigenschaften geändert haben, können beim Zugriff auf die wiederhergestellten Objekte Fehler auftreten.

• Bei Objekten auf Kontoebene verweisen alle Referenzen von wiederhergestellten Objekten immer auf das ursprüngliche Objekt auf Kontoebene. Das liegt daran, dass die Objekte auf Kontoebene nicht Teil eines Snapshots sind. Ein Schema-Snapshot könnte zum Beispiel ein Geheimnis enthalten, das auf eine Sicherheitsintegration verweist. Die Sicherheitsintegration ist ein Objekt auf Kontoebene und kann nicht in einen Snapshot aufgenommen werden.

Objekttypen in Datenbank- und Schema-Snapshots¶

In der folgenden Tabelle sind die Objekte aufgeführt, die in einem Datenbank- oder Schema-Snapshot enthalten sind:

Wie Snowflake Objekte mit den dazugehörigen Snapshot-Sets verknüpft¶

Wenn Sie ein Snapshot-Set für eine Datenbank, ein Schema oder eine Tabelle erstellen, verknüpft Snowflake das Snapshot-Set mit der internen ID dieser Datenbank, dieses Schemas oder dieser Tabelle. Wenn Sie das ursprüngliche Objekt löschen, können Sie diesem Snapshot-Set keine weiteren Snapshots hinzufügen. Dieses Verhalten gilt auch dann, wenn Sie ein Objekt mit demselben Namen neu erstellen oder es durch ein Objekt ersetzen, das aus einem Snapshot wiederhergestellt wurde.

Wenn Sie stattdessen das ursprüngliche Objekt umbenennen, können Sie weitere Backups davon erstellen, indem Sie weitere Snapshots zum selben Snapshot-Set hinzufügen. In diesem Fall ändert sich die Ausgabe von SHOW SNAPSHOT SETS, um den OBJECT_NAME-Wert des umbenannten Objekts zu berücksichtigen.

Wenn Sie Backups einer Tabelle erstellen möchten, diese Tabelle aber häufig löschen und neu erstellen, z. B. über CREATE OR REPLACE-Anweisungen, nehmen Sie sie in ein Snapshot-Set für das Schema oder die Datenbank auf, die die Tabelle enthält. Auf diese Weise können Sie unabhängig von den Änderungen an der Tabelle weiterhin dasselbe Snapshot-Set verwenden.

Wenn Sie eine Tabelle aus einem Snapshot wiederherstellen, beginnt die wiederhergestellte Tabelle mit einem anderen Namen als die ursprüngliche Tabelle. Angenommen, Sie möchten den Inhalt der ursprünglichen Tabelle vollständig durch die Snapshot-Daten ersetzen und weiterhin dasselbe Snapshot-Set für weitere Backups derselben Tabelle verwenden. Verwenden Sie in diesem Fall die Anweisung TRUNCATE oder DELETE zum Entfernen des Inhalts der ursprünglichen Tabelle sowie die Anweisung INSERT … SELECT zum Kopieren der Daten aus der wiederhergestellten Tabelle. Löschen Sie nicht die ursprüngliche Tabelle, und benennen Sie die wiederhergestellte Tabelle nicht in den Namen der ursprünglichen Tabelle um.

Snapshots und Verschlüsselung¶

Die Daten in Snapshot-Sets sind durch dieselbe End-to-End-Verschlüsselung geschützt wie andere Snowflake-Objekte und -Tabellendaten. Weitere Informationen zur Snowflake-Verschlüsselung finden Sie unter Erläuterungen zur End-to-End-Verschlüsselung in Snowflake.

Die Schlüsselrotation gilt auch für die Daten in Snapshots.

Snapshots und Datenherkunft¶

Snowflake behält nicht die Datenherkunft Metadaten bei Datenbank-, Schema- und Tabellen-Snapshots bei. Nachdem Sie ein Objekt aus einem Snapshot wiederhergestellt haben, können Sie Snowsight nicht mehr verwenden, um Herkunftsinformationen für die wiederhergestellten Daten anzuzeigen.

Erforderliche Berechtigungen erteilen, um Snapshot-Richtlinien und -Sets zu erstellen¶

Zum Aktivieren der Rolle myrole, um eine Snapshot-Richtlinie im Schema myschema zu erstellen, führen Sie die folgende Anweisung aus:

GRANT CREATE SNAPSHOT POLICY ON SCHEMA policy_schema TO ROLE myrole;

Zum Aktivieren der Rolle myrole, um einen Snapshot im Schema myschema zu erstellen, führen Sie die folgende Anweisung aus:

GRANT CREATE SNAPSHOT SET ON SCHEMA policy_schema TO ROLE myrole;

Einer Rolle die APPLY-Berechtigung für eine Snapshot-Richtlinie erteilen¶

Zum Aktivieren der Rolle myrole, um die Snapshot-Richtlinie hourly_snapshot_policy auf ein Snapshot-Set anzuwenden, führen Sie die folgende Anweisung aus:

GRANT APPLY ON SNAPSHOT POLICY hourly_snapshot_policy TO ROLE myrole;

Einer Rolle die Berechtigung APPLY SNAPSHOT RETENTION LOCK erteilen¶

Sie können einer Rolle die Berechtigung erteilen, Snapshot-Richtlinien mit einer Aufbewahrungssperre auf Snapshot-Sets anzuwenden.

Nur ein Benutzer mit der ACCOUNTADMIN-Rolle kann diese Berechtigung erteilen.

Zum Aktivieren der Rolle retention_lock_admin_role, um eine Snapshot-Richtlinie mit einer Aufbewahrungssperre auf ein Snapshot-Set anzuwenden, führen Sie die folgende Anweisung aus:

GRANT APPLY SNAPSHOT RETENTION LOCK ON ACCOUNT TO ROLE retention_lock_admin_role;

Geplante Snapshots erstellen¶

Erstellen Sie ein Snapshot-Set, das automatisch Snapshots nach einem Zeitplan erstellt.

1. Erstellen Sie eine Snapshot-Richtlinie unter Verwendung des Befehls CREATE SNAPSHOT POLICY. Die folgende Richtlinie erstellt zum Beispiel jede Stunde einen Snapshot, beginnend mit dem Zeitpunkt, an dem das Snapshot-Set erstellt wird. Jeder Snapshot verfällt nach 90 Tagen.

   CREATE SNAPSHOT POLICY hourly_snapshot_policy
     SCHEDULE = '60 MINUTE'
     EXPIRE_AFTER_DAYS = 90
     COMMENT = 'Hourly backups expire after 90 days';
   

   Copy

2. Erstellen Sie ein Snapshot-Set für die Tabelle t1 mit der Snapshot-Richtlinie hourly_snapshot_policy:

   CREATE SNAPSHOT SET t1_snapshots
     FOR TABLE t1
     WITH SNAPSHOT POLICY hourly_snapshot_policy;
   

   Copy

3. Erstellen Sie ein Snapshot-Set für das Schema s1 mit der Snapshot-Richtlinie hourly_snapshot_policy:

   CREATE SNAPSHOT SET s1_snapshots
     FOR SCHEMA s1
     WITH SNAPSHOT POLICY hourly_snapshot_policy;
   

   Copy

4. Erstellen Sie ein Snapshot-Set für die Datenbank d1 mit der Snapshot-Richtlinie hourly_snapshot_policy:

   CREATE SNAPSHOT SET d1_snapshots
     FOR DATABASE d1
     WITH SNAPSHOT POLICY hourly_snapshot_policy;
   

   Copy

Geplante Snapshots mit einer Aufbewahrungssperre erstellen¶

Erstellen Sie ein Snapshot-Set, das automatisch Snapshots mit einer Aufbewahrungssperre nach einem Zeitplan erstellt. Die Aufbewahrungssperre verhindert, dass Benutzer, also auch berechtigte Benutzer, Snapshots in einem Snapshot-Set löschen oder ändern können, mit dem die Richtlinie verknüpft ist.

Nur eine Rolle, die die Berechtigung APPLY SNAPSHOT RETENTION LOCK für das Konto hat, kann eine Snapshot-Richtlinie mit einer Aufbewahrungssperre erstellen.

1. Erstellen Sie eine Richtlinie mit einer Aufbewahrungssperre, die einen täglichen Snapshot mit einem Ablaufzeitraum von 90 Tagen erstellt:

   CREATE SNAPSHOT POLICY daily_snapshot_policy_with_lock
     WITH RETENTION LOCK
     SCHEDULE = '1440 MINUTE'
     EXPIRE_AFTER_DAYS = 90
     COMMENT = 'regulatory backups: they have a retention lock and expire after 90 days';
   

   Copy

2. Erstellen Sie ein Snapshot-Set für die Tabelle t2 mit der Snapshot-Richtlinie daily_snapshot_policy_with_lock:

   CREATE SNAPSHOT SET t2_snapshots
     FOR TABLE t2
     WITH SNAPSHOT POLICY daily_snapshot_policy_with_lock;
   

   Copy

3. Erstellen Sie ein Snapshot-Set für das Schema s2 mit der Snapshot-Richtlinie daily_snapshot_policy_with_lock:

   CREATE SNAPSHOT SET s2_snapshots
     FOR SCHEMA s2
     WITH SNAPSHOT POLICY daily_snapshot_policy_with_lock;
   

   Copy

4. Erstellen Sie ein Snapshot-Set für die Datenbank d2 mit der Snapshot-Richtlinie daily_snapshot_policy_with_lock:

   CREATE SNAPSHOT SET d2_snapshots
     FOR DATABASE d2
     WITH SNAPSHOT POLICY daily_snapshot_policy_with_lock;
   

   Copy

Snapshots manuell erstellen¶

Sie können einen Snapshot jederzeit manuell zu einem Snapshot-Set hinzufügen. Dadurch wird ein Snapshot der Datenbank, des Schemas oder der Tabelle erstellt, die mit dem Snapshot-Set verbunden ist. Sie können Snapshots manuell erstellen, unabhängig davon, ob das Snapshot-Set auch Snapshots enthält, die durch eine Snapshot-Richtlinie geplant sind. Wenn mit dem Snapshot-Set eine Snapshot-Richtlinie verknüpft ist, und die Richtlinie einen Ablaufzeitraum definiert, gilt dieser Ablaufzeitraum auch für den manuellen Snapshot.

Im folgenden Beispiel wird ein Tabellen-Snapshot-Set t1_snapshots erstellt und dann der erste Snapshot hinzugefügt:

CREATE SNAPSHOT SET t1_snapshots FOR TABLE t1;
ALTER SNAPSHOT SET t1_snapshots ADD SNAPSHOT;

Das folgende Beispiel erstellt eine Snapshot-Richtlinie mit stündlichen Backups, ein Tabellen-Snapshot-Set t2_snapshots, das die Richtlinie verwendet und dann einen manuellen Snapshot zum Snapshot-Set hinzufügt:

CREATE SNAPSHOT POLICY hourly_snapshot_policy
  SCHEDULE = '60 MINUTE'
  EXPIRE_AFTER_DAYS = 7;

CREATE SNAPSHOT SET t2_snapshots FOR TABLE t2 WITH SNAPSHOT POLICY hourly_snapshot_policy;
-- Wait several hours. Then the snapshot set already contains several scheduled snapshots.
-- You can manually add a snapshot at any time, in addition to the scheduled snapshots.
ALTER SNAPSHOT SET t2_snapshots ADD SNAPSHOT;

Sie können ähnliche Befehle ausführen, um einen Snapshot zu einem Schema- oder Datenbank-Snapshot-Set hinzuzufügen. Ersetzen Sie den Namen des Schema- oder Datenbank-Snapshots, der im Befehl ALTER SNAPSHOT SET festgelegt wurde.

Eine Snapshot-Richtlinie für ein Snapshot-Set aussetzen¶

Wenn Sie eine Snapshot-Richtlinie für ein Snapshot-Set aussetzen, verhindern Sie, dass die Snapshot-Richtlinie verwendet wird, um neue geplante Snapshots in diesem Snapshot-Set zu erstellen. Sie setzen auch das Ablaufen von vorhandenen Snapshots in diesem Snapshot-Set aus, die die Snapshot-Richtlinie verwenden. Andere Snapshot-Sets, die dieselbe Richtlinie verwenden, sind davon nicht betroffen.

Im folgenden Beispiel wird eine Snapshot-Richtlinie für das Snapshot-Set t2_snapshots ausgesetzt:

ALTER SNAPSHOT SET t2_snapshots SUSPEND SNAPSHOT POLICY;

Copy

Weitere Informationen über den Befehl ALTER SNAPSHOT SET finden Sie unter ALTER SNAPSHOT SET.

Eine Snapshot-Richtlinie für ein Snapshot-Set fortsetzen¶

Sie können ausgesetzte Snapshot-Richtlinien fortsetzen. Dadurch werden das Erstellen und das Ablaufen von Snapshots gemäß der Snapshot-Richtlinie fortgesetzt. Wenn ein Snapshot das Ablaufdatum erreicht hat, während die Richtlinie ausgesetzt wurde, löscht Snowflake diese Snapshots, sobald die Richtlinie fortgesetzt wird.

Das folgende Beispiel setzt eine Snapshot-Richtlinie auf dem Snapshot-Set t1_snapshot fort:

ALTER SNAPSHOT SET t1_snapshots
  RESUME SNAPSHOT POLICY;

Copy

Weitere Informationen über den Befehl ALTER SNAPSHOT SET finden Sie unter ALTER SNAPSHOT SET.

Snapshots wiederherstellen¶

Sie können ein Objekt aus einem Snapshot-Set wiederherstellen, indem Sie die ID des jeweiligen Snapshots verwenden. Um beispielsweise die Tabelle t1 aus dem Snapshot-Set t1_snapshots im aktuellen Schema wiederherzustellen, führen Sie die folgenden Anweisungen aus:

1. Suchen Sie die ID des Tabellen-Snapshots, der in der Spalte snapshot_id wiederhergestellt werden soll:

   SHOW SNAPSHOTS IN SNAPSHOT SET t1_snapshots ->> SELECT "created_on", "snapshot_id", "expire_on" FROM $1;
   

   Copy

   +-------------------------------+--------------------------------------+-------------------------------+
   | created_on                    | snapshot_id                          | expire_on                     |
   |-------------------------------+------------------------------------------+---------------------------|
   | 2024-08-19 17:12:28.991 -0700 | 983e0b66-91eb-41cb-8a0b-037abfec1914 | 2024-08-20 17:12:28.991 -0700 |
   | 2024-08-19 18:12:33.824 -0700 | b5624ef0-1f35-452f-b132-09d8f0592e52 | 2024-08-20 18:12:33.824 -0700 |
   | 2024-08-19 19:12:43.830 -0700 | eca1a94a-fd40-46db-a2bc-4afba6a38c0a | 2024-08-20 19:12:43.830 -0700 |
   | 2024-08-19 20:12:45.446 -0700 | 8ee2fd7e-1afe-42e1-acd7-79582765a910 | 2024-08-20 20:12:45.446 -0700 |
   | 2024-08-19 21:12:55.305 -0700 | d38caf14-f8a5-4ba8-a248-8287e0cdcf40 | 2024-08-20 21:12:55.305 -0700 |
   +-------------------------------+--------------------------------------+-----------+-------------------+
   

2. Suchen Sie die ID des Schema-Snapshots, der in der Spalte snapshot_id wiederhergestellt werden soll:

   SHOW SNAPSHOTS IN SNAPSHOT SET s1_snapshots;
   

   Copy

   +-------------------------------+--------------------------------------+-------------------------------+
   | created_on                    | snapshot_id                          | expire_on                     |
   |-------------------------------+--------------------------------------+-------------------------------|
   | 2024-08-19 17:12:28.991 -0700 | 0a0382e1-d265-46e9-b152-4c3b2b859e65 | 2024-08-20 17:12:28.991 -0700 |
   | 2024-08-19 18:12:33.824 -0700 | 8dbcf919-3393-4590-928f-5481d7f2502f | 2024-08-20 18:12:33.824 -0700 |
   | 2024-08-19 19:12:43.830 -0700 | 8ee2fd7e-1afe-42e1-acd7-79582765a910 | 2024-08-20 19:12:43.830 -0700 |
   | 2024-08-19 20:12:45.446 -0700 | bd729a79-01bc-444d-a550-adaaa31ab62f | 2024-08-20 20:12:45.446 -0700 |
   | 2024-08-19 21:12:55.305 -0700 | 9a8802c5-5fbd-4200-a09d-43e046103939 | 2024-08-20 21:12:55.305 -0700 |
   +-------------------------------+--------------------------------------+-------------------------------+
   

3. Suchen Sie die ID des Datenbank-Snapshots, der in der Spalte snapshot_id wiederhergestellt werden soll:

   SHOW SNAPSHOTS IN SNAPSHOT SET d1_snapshots;
   

   Copy

   +-------------------------------+--------------------------------------+-------------------------------+
   | created_on                    | snapshot_id                          | expire_on                     |
   |-------------------------------+--------------------------------------+-------------------------------|
   | 2024-08-19 17:12:28.991 -0700 | 42435925-4e77-4b01-ba89-8163ac03e12f | 2024-08-20 17:12:28.991 -0700 |
   | 2024-08-19 18:12:33.824 -0700 | 29c2c1b9-6599-4f0b-87b8-d43377fd7c77 | 2024-08-20 18:12:33.824 -0700 |
   | 2024-08-19 19:12:43.830 -0700 | a4283984-a063-4415-acc4-0e3c19259fad | 2024-08-20 19:12:43.830 -0700 |
   | 2024-08-19 20:12:45.446 -0700 | ffe25397-64b9-4c5f-b061-23a1885dc2dc | 2024-08-20 20:12:45.446 -0700 |
   | 2024-08-19 21:12:55.305 -0700 | 28e12b8a-aab8-40a8-ae39-9a5a5f654d66 | 2024-08-20 21:12:55.305 -0700 |
   +-------------------------------+--------------------------------------+-------------------------------+
   

4. Stellen Sie den Snapshot für die Tabelle t1 wieder her der am 19.08.2024 um 18:12:33 erstellt wurde:

   CREATE TABLE restored_t1 FROM SNAPSHOT SET t1_snapshots IDENTIFIER 'b5624ef0-1f35-452f-b132-09d8f0592e52';
   

   Copy

5. Stellen Sie den Snapshot für das Schema s1 wieder her, der am 19.08.2024 um 18:12:33 erstellt wurde:

   CREATE SCHEMA restored_s1 FROM SNAPSHOT SET s1_snapshots IDENTIFIER '8dbcf919-3393-4590-928f-5481d7f2502f';
   

   Copy

6. Stellen Sie den Snapshot für die Datenbank d1 wieder her, der am 19.08.2024 um 18:12:33 erstellt wurde:

   CREATE DATABASE restored_d1 FROM SNAPSHOT SET d1_snapshots IDENTIFIER '29c2c1b9-6599-4f0b-87b8-d43377fd7c77';
   

   Copy

Einen Snapshot aus einem Snapshot-Set löschen¶

Bei jedem Snapshot-Set können Sie nur den ältesten Snapshot löschen, für den es keine gesetzliche Aufbewahrungsfrist gibt. Dazu geben Sie die Snapshot-ID an. Sie können die Snapshots suchen, die keine gesetzliche Aufbewahrungsfrist haben, indem Sie die is_under_legal_hold-Eigenschaft überprüfen. Sie können den ältesten Snapshot suchen, indem Sie die created_on-Eigenschaft überprüfen.

Bemerkung

Sie können keinen Snapshot aus einem Snapshot-Set löschen, wenn eine Snapshot-Richtlinie mit einer Aufbewahrungssperre mit diesem Snapshot-Set verbunden ist oder wenn auf diesen Snapshot eine gesetzliche Aufbewahrungsfrist angewendet wird.

Der Snapshot, den Sie aus dem Snapshot-Set löschen, muss der früheste Snapshot im Set sein.

1. Suchen Sie die ID des zu löschenden Tabellen-Snapshots in der Spalte snapshot_id in der folgenden Ausgabe. Durch die Sortierung in aufsteigender Reihenfolge in der Spalte created_on wird der älteste Snapshot an die erste Stelle gesetzt. Sie könnten LIMIT 1 zum SELECT-Befehl hinzufügen, um nur die Zeile mit den Details des ältesten Snapshots zurückzugeben.

   SHOW SNAPSHOTS IN SNAPSHOT SET t1_snapshots ->>
     SELECT "created_on", "snapshot_id", "expire_on" FROM $1
       WHERE "is_under_legal_hold" = 'N'
       ORDER BY "created_on";
   

   Copy

   +-------------------------------+--------------------------------------+-------------------------------+
   | created_on                    | snapshot_id                          | expire_on                     |
   |-------------------------------+--------------------------------------+-------------------------------|
   | 2024-08-19 17:12:28.991 -0700 | 983e0b66-91eb-41cb-8a0b-037abfec1914 | 2024-08-20 17:12:28.991 -0700 |
   | 2024-08-19 18:12:33.824 -0700 | b5624ef0-1f35-452f-b132-09d8f0592e52 | 2024-08-20 18:12:33.824 -0700 |
   | 2024-08-19 19:12:43.830 -0700 | eca1a94a-fd40-46db-a2bc-4afba6a38c0a | 2024-08-20 19:12:43.830 -0700 |
   | 2024-08-19 20:12:45.446 -0700 | 8ee2fd7e-1afe-42e1-acd7-79582765a910 | 2024-08-20 20:12:45.446 -0700 |
   | 2024-08-19 21:12:55.305 -0700 | d38caf14-f8a5-4ba8-a248-8287e0cdcf40 | 2024-08-20 21:12:55.305 -0700 |
   +-------------------------------+--------------------------------------+-------------------------------+
   

2. Löschen Sie den t1_snapshots-Snapshot, der am 19.08.2024 um 17:12:28 unter Verwendung der snapshot_id erstellt wurde:

   ALTER SNAPSHOT SET t1_snapshots DELETE SNAPSHOT IDENTIFIER '983e0b66-91eb-41cb-8a0b-037abfec1914';
   

   Copy

3. Suchen Sie die ID des zu löschenden Schema-Snapshots in der Spalte snapshot_id in der folgenden Ausgabe:

   SHOW SNAPSHOTS IN SNAPSHOT SET s1_snapshots ->>
     SELECT "created_on", "snapshot_id", "expire_on" FROM $1 ORDER BY "created_on";
   

   Copy

   +-------------------------------+--------------------------------------+-------------------------------+
   | created_on                    | snapshot_id                          | expire_on                     |
   |-------------------------------+--------------------------------------+-------------------------------|
   | 2024-08-19 17:12:28.991 -0700 | 28e12b8a-aab8-40a8-ae39-9a5a5f654d66 | 2024-08-20 17:12:28.991 -0700 |
   | 2024-08-19 18:12:33.824 -0700 | 46a1e22a-8557-432f-a14c-1261a4ca2b34 | 2024-08-20 18:12:33.824 -0700 |
   | 2024-08-19 19:12:43.830 -0700 | 3e42fef6-b895-4055-a59f-179744d015d3 | 2024-08-20 19:12:43.830 -0700 |
   | 2024-08-19 20:12:45.446 -0700 | 7807d24e-285e-4741-b332-87c32bad5cb6 | 2024-08-20 20:12:45.446 -0700 |
   | 2024-08-19 21:12:55.305 -0700 | e022e619-ee83-45a0-b2b7-9007e284bdb3 | 2024-08-20 21:12:55.305 -0700 |
   +-------------------------------+--------------------------------------+-------------------------------+
   

4. Löschen Sie den s1_snapshots-Snapshot, der am 19.08.2024 um 17:12:28 unter Verwendung der snapshot_id erstellt wurde:

   ALTER SNAPSHOT SET s1_snapshots DELETE SNAPSHOT IDENTIFIER '28e12b8a-aab8-40a8-ae39-9a5a5f654d66';
   

   Copy

5. Suchen Sie die ID des zu löschenden Datenbank-Snapshots in der Spalte snapshot_id in der folgenden Ausgabe:

   SHOW SNAPSHOTS IN SNAPSHOT SET d1_snapshots ->>
     SELECT "created_on", "snapshot_id", "expire_on" FROM $1 ORDER BY "created_on";
   

   Copy

   +-------------------------------+--------------------------------------+-------------------------------+
   | created_on                    | snapshot_id                          | expire_on                     |
   |-------------------------------+--------------------------------------+-------------------------------|
   | 2024-08-19 17:12:28.991 -0700 | d3a77432-c98d-4969-91a9-fffae5dd655c | 2024-08-20 17:12:28.991 -0700 |
   | 2024-08-19 18:12:33.824 -0700 | 0a0382e1-d265-46e9-b152-4c3b2b859e65 | 2024-08-20 18:12:33.824 -0700 |
   | 2024-08-19 19:12:43.830 -0700 | 25e01ee0-ea9d-4bb7-af7f-f3fe87f9409e | 2024-08-20 19:12:43.830 -0700 |
   | 2024-08-19 20:12:45.446 -0700 | a12294f5-fc63-49cf-84f1-c7b72f7664af | 2024-08-20 20:12:45.446 -0700 |
   | 2024-08-19 21:12:55.305 -0700 | 28e12b8a-aab8-40a8-ae39-9a5a5f654d66 | 2024-08-20 21:12:55.305 -0700 |
   +-------------------------------+--------------------------------------+-------------------------------+
   

6. Löschen Sie den d1_snapshots-Snapshot, der am 19.08.2024 um 17:12:28 unter Verwendung der snapshot_id erstellt wurde:

   ALTER SNAPSHOT SET d1_snapshots DELETE SNAPSHOT IDENTIFIER 'd3a77432-c98d-4969-91a9-fffae5dd655c';
   

   Copy

7. Versuchen Sie, einen neueren d1_snapshots-Snapshot zu löschen, der am 19.08.2024 um 21:12:55 erstellt wurde. Beachten Sie, wie Snowflake verhindert, dass Sie einen Snapshot löschen, der nicht der älteste im Snapshot-Set ist.

   ALTER SNAPSHOT SET d1_snapshots DELETE SNAPSHOT IDENTIFIER '28e12b8a-aab8-40a8-ae39-9a5a5f654d66';
   

   Copy

   Snapshot '28e12b8a-aab8-40a8-ae39-9a5a5f654d66' cannot be deleted as it is not the oldest active snapshot in the snapshot set D1_SNAPSHOTS.
   

Snapshot-Sets löschen¶

Sie können ein Snapshot-Set mit dem Befehl DROP SNAPSHOT SET löschen.

Löschen Sie das Snapshot-Set t1_snapshots:

DROP SNAPSHOT SET t1_snapshots;

Löschen Sie das Snapshot-Set s1_snapshots:

DROP SNAPSHOT SET s1_snapshots;

Löschen Sie das Snapshot-Set d1_snapshots:

DROP SNAPSHOT SET d1_snapshots;

Alle Snapshot-Sets suchen, die Backups einer bestimmten Tabelle enthalten¶

Das folgende Beispiel zeigt, wie Sie alle Snapshot-Sets suchen, die eine bestimmte Tabelle innerhalb eines bestimmten Schemas und einer bestimmten Datenbank enthalten. Der Befehl SHOW TABLES verwendet einen Pipe-Operator, um die Namen von Datenbank, Schema und Tabelle abzurufen und sie in Variablen zu speichern. Die Ausgabe von SHOW SNAPSHOT SETS wird gefiltert, um die Snapshot-Sets anzuzeigen, die die Datenbank, die die Tabelle enthält, oder das Schema, das die Tabelle enthält, oder die diese einzelne Tabelle enthält, sichern.

Die gefilterte Ausgabe von SHOW SNAPSHOT SETS zeigt, dass es zwei Datenbank-Snapshot-Sets für die Datenbank MY_BIG_IMPORTANT_DATABASE, ein Schema-Snapshot-Set für das Schema MY_BIG_IMPORTANT_DATABASE.PUBLIC und ein Tabellen-Snapshot-Set für die Tabelle MY_BIG_IMPORTANT_DATABASE.PUBLIC.MY_SMALL_SECONDARY_TABLE gibt.

SHOW TABLES IN SCHEMA public ->>
  SET (dname, sname, tname) =
    (SELECT "database_name", "schema_name", "name" FROM $1
      WHERE "name" = 'MY_SMALL_SECONDARY_TABLE' AND "kind" = 'TABLE');

SHOW SNAPSHOT SETS ->> SELECT "object_kind", "name", "database_name", "schema_name", "object_name" FROM $1
  WHERE ("object_kind" = 'TABLE' AND "database_name" = $dname AND "schema_name" = $sname AND "object_name" = $tname)
    OR ("object_kind" = 'SCHEMA' AND "database_name" = $dname AND "object_name" = $sname)
    OR ("object_kind" = 'DATABASE' AND "object_name" = $dname);

+-------------+------------------+---------------------------+-------------+---------------------------+
| object_kind | name             | database_name             | schema_name | object_name               |
|-------------+------------------+---------------------------+-------------+---------------------------|
| DATABASE    | DATABASE_BACKUP  | MY_BIG_IMPORTANT_DATABASE | PUBLIC      | MY_BIG_IMPORTANT_DATABASE |
| DATABASE    | DATABASE_BACKUP2 | MY_BIG_IMPORTANT_DATABASE | PUBLIC      | MY_BIG_IMPORTANT_DATABASE |
| SCHEMA      | SCHEMA_BACKUP3   | MY_BIG_IMPORTANT_DATABASE | PUBLIC      | PUBLIC                    |
| TABLE       | TABLE_BACKUP2    | MY_BIG_IMPORTANT_DATABASE | PUBLIC      | MY_SMALL_SECONDARY_TABLE  |
+-------------+------------------+---------------------------+-------------+---------------------------+

Snapshots für eine Tabelle mit Abhängigkeiten erstellen¶

Die folgenden Beispiele zeigen, wie Sie einen Tabellen-Snapshot für eine Tabelle erstellen können, die auf eine Sequenz und einen Fremdschlüssel in einem anderen Schema verweist. Zur Vorbereitung erstellen wir das Schema other_schema, das eine Sequenz und eine Tabelle enthält. Dann wird im Schema public die Haupttabelle erstellt, die sich auf die Sequenz und die andere Tabelle bezieht.

USE DATABASE my_big_important_database;

CREATE SCHEMA other_schema;
USE SCHEMA other_schema;

CREATE SEQUENCE my_sequence;
CREATE TABLE my_dimension_table (id INT AUTOINCREMENT PRIMARY KEY);

USE SCHEMA public;
CREATE TABLE dependent_table
(
   id INT DEFAULT my_big_important_database.other_schema.my_sequence.NEXTVAL PRIMARY KEY,
   foreign_id INT,
   FOREIGN KEY (foreign_id) REFERENCES my_big_important_database.other_schema.my_dimension_table(id)
 );

SELECT GET_DDL('TABLE','dependent_table');

Die Ausgabe GET_DDL () zeigt die Referenzen an, die auf das andere Schema verweisen:

+-------------------------------------------+
| GET_DDL('TABLE','DEPENDENT_TABLE')        |
|-------------------------------------------|
| create or replace TABLE DEPENDENT_TABLE ( |
|     ID NUMBER(38,0) NOT NULL DEFAULT MY_BIG_IMPORTANT_DATABASE.OTHER_SCHEMA.MY_SEQUENCE.NEXTVAL,
|     FOREIGN_ID NUMBER(38,0),                |
|     primary key (ID),                       |
|     foreign key (FOREIGN_ID) references MY_BIG_IMPORTANT_DATABASE.OTHER_SCHEMA.MY_DIMENSION_TABLE(ID)
| );                                        |
+-------------------------------------------+

Als Nächstes erstellen wir das Snapshot-Set für die Tabelle und fügen einen Snapshot hinzu:

CREATE SNAPSHOT SET dependency_experiments FOR TABLE dependent_table;
ALTER SNAPSHOT SET dependency_experiments ADD SNAPSHOT;
SHOW SNAPSHOTS IN SNAPSHOT SET dependency_experiments;

Die Ausgabe SHOW SNAPSHOTS enthält den snapshot_id-Wert, der für die Wiederherstellungsoperation verwendet werden soll:

+-------------------------------+--------------------------------------+------------------------+---------------------------+--------------+-----------+
| created_on                    | snapshot_id                          | snapshot_set_name      | database_name             | schema_name  | expire_on |
|-------------------------------+--------------------------------------+------------------------+---------------------------+--------------+-----------|
| 2025-07-01 11:53:27.860 -0700 | 0fd44138-b571-449b-be0a-72779501f80e | DEPENDENCY_EXPERIMENTS | MY_BIG_IMPORTANT_DATABASE | OTHER_SCHEMA | NULL      |
+-------------------------------+--------------------------------------+------------------------+---------------------------+--------------+-----------+

Wir stellen diese Tabelle unter einem neuen Namen wieder her und bestätigen, dass die wiederhergestellte Tabelle auf die Objekte im anderen Schema verweist:

CREATE TABLE restored_dependent_table FROM SNAPSHOT SET dependency_experiments
  IDENTIFIER '0fd44138-b571-449b-be0a-72779501f80e';

SELECT GET_DDL('TABLE','restored_dependent_table');

+----------------------------------------------------+
| GET_DDL('TABLE','RESTORED_DEPENDENT_TABLE')        |
|----------------------------------------------------|
| create or replace TABLE RESTORED_DEPENDENT_TABLE ( |
|     ID NUMBER(38,0) NOT NULL DEFAULT MY_BIG_IMPORTANT_DATABASE.OTHER_SCHEMA.MY_SEQUENCE.NEXTVAL,
|     FOREIGN_ID NUMBER(38,0),                         |
|     foreign key (FOREIGN_ID) references MY_BIG_IMPORTANT_DATABASE.OTHER_SCHEMA.MY_DIMENSION_TABLE(ID),
|     primary key (ID)                                 |
| );                                                 |
+----------------------------------------------------+

Um zu veranschaulichen, was passiert, wenn das referenzierte Objekt nicht mehr existiert, löschen wir die Sequenz und stellen dann die Tabelle aus demselben Snapshot wieder her:

DROP SEQUENCE my_big_important_database.other_schema.my_sequence;
CREATE TABLE OR REPLACE restored_dependent_table FROM SNAPSHOT SET dependency_experiments
  IDENTIFIER '0fd44138-b571-449b-be0a-72779501f80e';

SELECT * FROM restored_dependent_table;

Das Abfragen der Tabelle funktioniert immer noch:

+----+------------+
| ID | FOREIGN_ID |
|----+------------|
+----+------------+
0 Row(s) produced. Time Elapsed: 0.129s

Allerdings schlagen Vorgänge wie GET_DDL(), DESCRIBE und INSERT fehl, weil sie von einer Sequenz abhängen, die nicht mehr existiert:

SELECT GET_DDL('TABLE','restored_dependent_table');

002073 (02000): SQL compilation error:
Sequence used as a default value in table 'MY_BIG_IMPORTANT_DATABASE.OTHER_SCHEMA.RESTORED_DEPENDENT_TABLE'
  column 'ID' was not found or could not be accessed.

DESC TABLE restored_dependent_table;

+------------+--------------+--------+-------+----------------------------------------+-------------+------------+-------+------------+---------+-------------+----------------+
| name       | type         | kind   | null? | default                                | primary key | unique key | check | expression | comment | policy name | privacy domain |
|------------+--------------+--------+-------+----------------------------------------+-------------+------------+-------+------------+---------+-------------+----------------|
| ID         | NUMBER(38,0) | COLUMN | N     | [sequence cannot be found or accessed] | Y           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| FOREIGN_ID | NUMBER(38,0) | COLUMN | Y     | NULL                                   | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+------------+--------------+--------+-------+----------------------------------------+-------------+------------+-------+------------+---------+-------------+----------------+

INSERT INTO restored_dependent_table (foreign_id) VALUES (2);

002073 (02000): SQL compilation error:
Sequence used as a default value in table 'MY_BIG_IMPORTANT_DATABASE.OTHER_SCHEMA.RESTORED_DEPENDENT_TABLE'
  column 'ID' was not found or could not be accessed.

Snapshots für eine dynamische Tabelle erstellen¶

Eine dynamische Tabelle enthält immer einen Verweis auf eine andere Tabelle. Aus diesem Grund können Sie es vorziehen, für dynamische Tabellen Schema-Snapshots oder Datenbank-Snapshots zu verwenden, sodass die ursprüngliche Tabelle und die dynamische Tabelle in demselben Snapshot enthalten sein können.

Wenn Sie einen Tabellen-Snapshot für eine dynamische Tabelle erstellen, fügen Sie das Schlüsselwort DYNAMIC in den Befehl CREATE SNAPSHOT SET und in die CREATE TABLE ein, wenn Sie von einem Snapshot wiederherstellen. Im folgenden Beispiel wird die dynamische Tabelle sowie ein Tabellen-Snapshot-Set für diese Tabelle eingerichtet und der erste Snapshot erstellt:

CREATE DYNAMIC TABLE my_dynamic_table
  TARGET_LAG = '1 minute'
  WAREHOUSE = my_wh
  AS SELECT * FROM my_base_table WHERE col1 IS NOT NULL;

CREATE SNAPSHOT SET dynamic_table_snapshots
  FOR DYNAMIC TABLE my_dynamic_table;

ALTER SNAPSHOT SET dynamic_table_snapshots ADD SNAPSHOT;

Das folgende Beispiel zeigt, wie Sie die Snapshot-IDs für Snapshots ermitteln, die zu verschiedenen Zeitpunkten erstellt wurden. In diesem Fall ist der neueste Snapshot die erste Zeile im Resultset. Dann verwenden Sie die ID des Snapshots im Befehl CREATE DYNAMIC TABLE.

SHOW SNAPSHOTS IN SNAPSHOT SET dynamic_table_snapshots
  ->> SELECT "created_on", "snapshot_id" FROM $1
        ORDER BY "created_on" DESC;

CREATE DYNAMIC TABLE restored_dynamic_table
  FROM SNAPSHOT SET dynamic_table_snapshots
    IDENTIFIER '<snapshot_id_from_SHOW_SNAPSHOTS_output>';

Gesetzliche Aufbewahrungsfristen hinzufügen und entfernen¶

Bevor Sie mit gesetzlichen Aufbewahrungsfristen für Snowflake-Snapshots arbeiten, sollten Sie sich über den Zweck und die Anforderungen informieren. Weitere Informationen dazu finden Sie unter Gesetzliche Aufbewahrungsfrist.

Angenommen, die Rechtsabteilung oder das Compliance-Team Ihrer Organisation sendet eine Anforderung zur Aufbewahrungsfrist, in der angegeben wird, welche Datentypen aufbewahrt werden müssen. In diesem Fall könnten Sie einem Prozess wie folgt folgen:

• Sie arbeiten mit der Rechtsabteilung zusammen, um herauszufinden, wo die relevanten Daten gespeichert sind und welche Snapshot-Sets die zugehörigen Objekte enthalten.

• Sie können für einen Snapshot ab einem entsprechenden Zeitrahmen eines Snapshot-Sets eine gesetzliche Aufbewahrungsfrist festlegen. Dadurch wird das automatische Ablaufen dieses Snapshots deaktiviert. Sie können für einen Snapshot, den Snowflake automatisch auf der Grundlage eines Zeitplans erstellt hat oder den Sie manuell erstellt haben, eine gesetzliche Aufbewahrungsfrist festlegen. Die gesetzliche Aufbewahrungsfrist gilt unabhängig davon, ob für das Snapshot-Set eine verknüpfte Snapshot-Richtlinie, ein Verfallszeitraum oder eine Aufbewahrungssperre vorhanden ist.

• Sie führen Aktualisierungsoperationen für alle sekundären Konten durch, in die die Datenbank, die das Snapshot-Set enthält, repliziert ist. Auf diese Weise bleiben die gesetzliche Aufbewahrungsfrist und der zugehörige Snapshot bei allen Failover- und Failback-Operationen erhalten.

• Sie verwenden die Zugriffssteuerung und Protokolle von Snowflake, um den Zugriff auf die Daten zu prüfen, die unter die gesetzliche Aufbewahrungsfrist fallen.

• Sobald der Fall abgeschlossen ist und die Rechtsabteilung die Entfernung der gesetzlichen Aufbewahrungsfrist genehmigt hat, gibt ein Benutzer mit der Berechtigung APPLY LEGAL HOLD die gesetzliche Aufbewahrungsfrist frei. Dann wird die normale Automatisierung für das Ablaufen fortgesetzt.

Dieses Beispiel zeigt die Sequenz von SQL-Befehlen, die Sie während des Lebenszyklus einer gesetzlichen Aufbewahrungsfrist für einen Snapshot innerhalb eines bestimmten Snapshot-Sets verwenden können. Sie finden den Bezeichner des entsprechenden Snapshots durch Verwendung des Befehls SHOW SNAPSHOTS IN SNAPSHOT SET und Überprüfung der Spalte "is_under_legal_hold", um zu sehen, ob bereits eine gesetzliche Aufbewahrungsfrist vorhanden ist. Dann fügen Sie die gesetzliche Aufbewahrungsfrist zum spezifischen Snapshot hinzu oder entfernen sie.

USE ROLE <role_name>; -- use a role that has the APPLY LEGAL HOLD privilege
SHOW SNAPSHOTS IN SNAPSHOT SET <snapshot_set_name>
  ->> SELECT * FROM $1 WHERE "is_under_legal_hold" = 'N';
ALTER SNAPSHOT SET <snapshot_set_name>
  MODIFY SNAPSHOT IDENTIFIER '<snapshot_identifier>'
  ADD LEGAL HOLD;

USE ROLE <role_name>; -- use a role that has the APPLY LEGAL HOLD privilege
SHOW SNAPSHOTS IN SNAPSHOT SET <snapshot_set_name>
  ->> SELECT * FROM $1 WHERE "is_under_legal_hold" = 'Y';
ALTER SNAPSHOT SET <snapshot_set_name>
  MODIFY SNAPSHOT IDENTIFIER '<snapshot_identifier>'
  REMOVE LEGAL HOLD;

Snapshot-bezogene Objekte replizieren¶

Wenn Sie die Replikation in Kombination mit Datenbank-, Schema- und Tabellen-Snapshots verwenden, geben Sie in Ihren Replikationsgruppen und Failover-Gruppen die Datenbanken an, die die Snapshot-Sets und Snapshot-Richtlinien enthalten. Sie können steuern, wie Ihre Snapshot-bezogenen Objekte repliziert werden, indem Sie Ihre Replikationsgruppen und Failover-Gruppen organisieren und auswählen, welche Datenbanken und Schemas Ihre Snapshot-Sets und Snapshot-Richtlinien enthalten. Weitere Informationen dazu finden Sie unter Snapshot-Replikation für Datenbank-, Schema- und Tabellen-Snapshots.

Die Snapshot-Sets und Snapshot-Richtlinien sind Datenbankobjekte. Snowflake repliziert die Snapshot-Sets und Snapshot-Richtlinien zusammen mit den Datenbanken und Schemas, die sie enthalten.

Snowflake minimiert den Zeit- und Speicherverbrauch von Snapshots durch einen Mechanismus ähnlich dem Klonen, sodass nicht für jeden Snapshot eine komplett neue Kopie aller Tabellendaten erforderlich ist. Wenn das Snapshot-Set Teil einer anderen Failover-Gruppe ist als die Datenbank, das Schema oder die Tabelle, für die das Snapshot-Set gilt, erfolgt einmalig eine vollständige Übertragung der Daten bei der ersten Aktualisierung dieser Replikations- oder Failover-Gruppe.

Wenn eine Replikationsgruppe oder Failover-Gruppe ein Snapshot-Set enthält, erhöht sich die Aktualisierungslatenz proportional zur Anzahl der Snapshots, die seit der letzten Aktualisierung erstellt wurden.

Wenn Sie einen Verfallszeitraum für ältere Snapshots definieren, erfolgt die automatische Löschung auf dem primären Konto. Diese abgelaufenen Snapshots werden aus dem zweiten Konto entfernt, wenn Sie eine Aktualisierungsoperation ausführen.

Daher können Sie die Replikation für Snapshot-bezogene Objekte feinabstimmen, indem Sie folgende Praktiken ausführen:

• Um die Wahrscheinlichkeit von Aktualisierungsfehlern zu minimieren, speichern Sie das Snapshot-Set und die optionale Snapshot-Richtlinie in derselben Datenbank und demselben Schema. Wenn das nicht praktisch ist, legen Sie diese Dinge in dieselbe Replikationsgruppe oder Failover-Gruppe. Auf diese Weise werden alle verwandten Objekte gleichzeitig repliziert.

• Um die Flexibilität bei der Replikation von Snapshot-bezogenen Objekten und beim Replikationsplan zu maximieren, speichern Sie das Snapshot-Set und die optionale Snapshot-Richtlinie in einer anderen Datenbank als der zugehörigen Datenbank, dem zugehörigen Schema oder der zugehörigen Tabelle. Auf diese Weise können Sie festlegen, ob und wie oft die Snapshot-bezogenen Objekte repliziert werden sollen.

• Wenn Sie eine Richtlinie mit einem Verfallszeitraum für ältere Snapshots anwenden, wählen Sie einen Verfallszeitraum länger als das Intervall zwischen den Aktualisierungsoperationen der Replikation aus. Auf diese Weise wird jeder neue Snapshot vor Ablauf mindestens einmal auf das zweite Konto repliziert.

• Führen Sie unmittelbar nach dem Hinzufügen einer gesetzlichen Aufbewahrungsfrist Aktualisierungsoperationen für alle Sekundärkonten durch, in die die Datenbank, die das Snapshot-Set enthält, repliziert wird. Auf diese Weise bleiben die gesetzliche Aufbewahrungsfrist und der zugehörige Snapshot bei allen Failover- und Failback-Operationen erhalten.

• Angenommen, Sie setzen eine Snapshot-Richtlinie und ein zugehöriges Snapshot-Set in Datenbanken, die Teil verschiedener Replikationsgruppen oder Failover-Gruppen sind. Stellen Sie in diesem Fall sicher, dass Sie die erste Aktualisierung zuerst in der Gruppe durchführen, die die Snapshot-Richtlinie enthält. Andernfalls schlägt die Aktualisierungsoperation fehl, weil Sie kein Snapshot-Set erstellen können, dem die zugehörige Snapshot-Richtlinie im Sekundärkonto fehlt.

  Bemerkung

  Wenn Sie das Snapshot-Set in eine andere Replikations- oder Failover-Gruppe als das Objekt des Snapshot-Sets setzen möchten, müssen Sie bei der ersten Aktualisierung der Gruppe, die das Snapshot-Set enthält, alle Daten vollständig übertragen.

  Wenn Sie einen Schema-Snapshot oder einen Datenbank-Snapshot in einem sekundären Konto wiederherstellen, werden Verweise auf Objekte innerhalb des wiederhergestellten Schemas oder der wiederhergestellten Datenbank möglicherweise nicht ordnungsgemäß aufgelöst, es sei denn, die referenzierten Objekte sind Teil derselben Failover-Gruppe wie der Snapshot.

Snapshots und Snapshot-Operationen überwachen¶

Sie können festlegen, welche Snapshot-bezogenen Objekte vorhanden sind, welche Eigenschaften sie haben und wie viel Speicherplatz sie verbrauchen, indem Sie die folgenden Ansichten abfragen.

Informationsschema:

• Ansicht SNAPSHOT_POLICIES

• Ansicht SNAPSHOT_SETS

• Ansicht SNAPSHOTS

Kontonutzung:

• Ansicht SNAPSHOT_OPERATION_HISTORY

• Ansicht SNAPSHOT_POLICIES

• Ansicht SNAPSHOT_SETS

• Ansicht SNAPSHOT_STORAGE_USAGE

• Ansicht SNAPSHOTS

Snapshot-Richtlinie¶

• CREATE SNAPSHOT POLICY

• ALTER SNAPSHOT POLICY

• DROP SNAPSHOT POLICY

• SHOW SNAPSHOT POLICIES

Snapshot-Set¶

• CREATE SNAPSHOT SET

• ALTER SNAPSHOT SET

• DROP SNAPSHOT SET

• SHOW SNAPSHOT SETS

Snapshots¶

Sie führen keinen tatsächlichen CREATE SNAPSHOT-Befehl aus. Um einen neuen Snapshot zu erstellen, führen Sie ALTER SNAPSHOT SET … ADD SNAPSHOT aus. Oder wenn Sie das Snapshot-Set mit einer Snapshot-Richtlinie verknüpfen, die einen Zeitplan hat, erstellt Snowflake automatisch Snapshots im Snapshot-Set auf der Grundlage des angegebenen Zeitplans. Um einen älteren Snapshot zu löschen, führen Sie ALTER SNAPSHOT SET … DELETE SNAPSHOT aus. Für solche Operationen müssen Sie den Bezeichner für einen bestimmten Snapshot angeben. Sie können die Bezeichner des Snapshots zusammen mit anderen Informationen suchen, z. B. wann der jeweilige Snapshot erstellt wurde, indem Sie den folgenden Befehl verwenden.

• SHOW SNAPSHOTS IN SNAPSHOT SET

Objekte aus Snapshots wiederherstellen¶

Sie verwenden die Syntax CREATE object_kind FROM SNAPSHOT SET, um jede Art von Objekt aus dem entsprechenden Typ von Snapshot-Set wiederherzustellen.

Weitere Snapshots im Snapshot-Set verwenden das ursprüngliche Objekt, nicht das wiederhergestellte Objekt. Dies gilt auch dann, wenn Sie das wiederhergestellte Objekt in denselben Namen wie das ursprüngliche Objekt umbenennen. Wenn Sie nach einer Wiederherstellung dasselbe Snapshot-Set weiter verwenden möchten, stellen Sie das Objekt unter einem neuen Namen wieder her und übertragen dann die Daten zurück in das ursprüngliche Objekt.

• CREATE DATABASE FROM SNAPSHOT SET

• CREATE SCHEMA FROM SNAPSHOT SET

• CREATE TABLE FROM SNAPSHOT SET

Ansichten¶

Die folgenden Systemansichten enthalten Metadaten zu Snapshots, Snapshot-Sets und Snapshot-Richtlinien.