Verwalten von Snowflake-Datenbanken, Schemas, Tabellen und Ansichten mit Python

Mit Python können Sie Snowflake-Datenbanken, Schemas, Tabellen und Ansichten verwalten. Weitere Informationen zum Verwalten und Verwenden von Daten in Snowflake finden Sie unter Datenbanken, Tabellen und Ansichten – Überblick.

Voraussetzungen

Die Beispiele in diesem Thema gehen davon aus, dass Sie Code hinzugefügt haben, um eine Verbindung zu Snowflake herzustellen und ein Root-Objekt zu erstellen, von dem aus Sie die Snowflake Python APIs verwenden können.

Beispielsweise verwendet der folgende Code Verbindungsparameter, die in einer Konfigurationsdatei definiert sind, um eine Verbindung zu Snowflake zu erstellen:

from snowflake.core import Root
from snowflake.snowpark import Session

session = Session.builder.config("connection_name", "myconnection").create()
root = Root(session)
Copy

Unter Verwendung des resultierenden Session-Objekts erstellt der Code ein Root-Objekt, das die Typen und Methoden der API verwendet. Weitere Informationen dazu finden Sie unter Verbinden mit Snowflake mit dem Snowflake Python APIs.

Verwalten von Datenbanken

Sie können Datenbanken in Snowflake verwalten. Die Snowflake Python APIs stellt Datenbanken mit zwei verschiedenen Typen dar:

  • Database: Zeigt die Eigenschaften einer Datenbank an, z. B. ihren Namen.

  • DatabaseResource: Stellt Methoden zur Verfügung, mit denen Sie ein entsprechendes Database-Objekt abrufen und die Datenbank löschen können.

Themen

Erstellen einer Datenbank

Sie können eine Datenbank erstellen, indem Sie die Methode DatabaseCollection.create aufrufen und ein Database-Objekt übergeben, das die zu erstellende Datenbank repräsentiert. Um eine Datenbank zu erstellen, erstellen Sie zunächst ein Database-Objekt, das den Namen der Datenbank angibt.

Der Code im folgenden Beispiel erstellt ein Database-Objekt, das eine Datenbank mit dem Namen my_db repräsentiert, und erstellt dann die Datenbank, indem das Database-Objekt an die Methode DatabaseCollection.create übergeben wird:

from snowflake.core.database import Database

my_db = Database(name="my_db")
root.databases.create(my_db)
Copy

Abrufen von Datenbankdetails

Sie können Informationen zu einer Datenbank erhalten, indem Sie die Methode DatabaseResource.fetch aufrufen, die ein Database-Objekt zurückgibt.

Der Code im folgenden Beispiel ruft Informationen über eine Datenbank mit dem Namen my_db ab:

my_db = root.databases["my_db"].fetch()
print(my_db.to_dict())
Copy

Auflisten von Datenbanken

Zum Auflisten von Datenbanken können Sie die Methode iter verwenden, die einen PagedIter-Iterator zurückgibt.

Der Code im folgenden Beispiel listet die Datenbanken auf, deren Name mit my beginnt:

databases = root.databases.iter(like="my%")
for database in databases:
  print(database.name)
Copy

Löschen einer Datenbank

Sie können eine Datenbank mit der DatabaseResource.drop-Methode löschen.

Der Code im folgenden Beispiel löscht die my_db-Datenbank:

my_db_res = root.databases["my_db"]
my_db_res.drop()
Copy

Verwalten von Schemas

Sie können Schemas in Snowflake verwalten. Ein Schema ist ein Objekt auf Datenbankebene. Wenn Sie ein Schema erstellen oder darauf verweisen, tun Sie dies im Kontext der zugehörigen Datenbank.

Die Snowflake Python APIs stellt Schemas mit zwei verschiedenen Typen dar:

  • Schema: Zeigt die Eigenschaften eines Schemas an, z. B. dessen Namen.

  • SchemaResource: Stellt Methoden zur Verfügung, mit denen Sie ein entsprechendes Schema-Objekt abrufen und das Schema löschen können.

Themen

Erstellen eines Schemas

Um ein Schema zu erstellen, erstellen Sie zunächst ein Schema-Objekt, das den Schemanamen angibt.

Der Code im folgenden Beispiel erstellt ein Schema-Objekt, das ein Schema mit dem Namen my_schema repräsentiert:

from snowflake.core.schema import Schema

my_schema = Schema(name="my_schema")
root.databases["my_db"].schemas.create(my_schema)
Copy

Der Code erstellt dann das Schema in der Datenbank my_db, indem das Schema-Objekt an die Methode SchemaCollection.create übergeben wird:

Abrufen von Schemadetails

Sie können Informationen zu einem Schema erhalten, indem Sie die Methode SchemaResource.fetch aufrufen, die ein Schema-Objekt zurückgibt.

Der Code im folgenden Beispiel ruft ein Schema-Objekt ab, das das Schema my_schema repräsentiert:

my_schema = root.databases["my_db"].schemas["my_schema"].fetch()
print(my_schema.to_dict())
Copy

Auflisten von Schemas

Mit der Methode iter können Sie die Schemas einer bestimmten Datenbank auflisten. Die Methode gibt einen PagedIter-Iterator für Schema-Objekte zurück.

Der Code im folgenden Beispiel listet Schemanamen der Datenbank my_db auf:

schema_list = root.databases["my_db"].schemas.iter()
for schema_obj in schema_list:
  print(schema_obj.name)
Copy

Löschen eines Schemas

Sie können ein Schema mit der SchemaResource.drop-Methode löschen.

Der Code im folgenden Beispiel löscht das my_schema-Schema:

my_schema_res = root.databases["my_db"].schemas["my_schema"]
my_schema_res.drop()
Copy

Verwalten von Standardtabellen

Sie können in Snowflake-Standardtabellen verwalten. Eine Tabelle ist ein Objekt auf Schemaebene. Wenn Sie eine Tabelle erstellen oder auf sie verweisen, tun Sie dies im Kontext des zugehörigen Schemas.

Die Snowflake Python APIs stellt Tabellen mit zwei verschiedenen Typen dar:

  • Table: Zeigt die Eigenschaften einer Tabelle an, z. B. den Namen und die Spalten.

  • TableResource: Stellt Methoden zur Verfügung, mit denen Sie ein entsprechendes Table-Objekt abrufen, die Eigenschaften der Tabelle aktualisieren und die Tabelle löschen können.

Themen

Erstellen von Tabellen

Um eine Tabelle zu erstellen, erstellen Sie zunächst ein Table-Objekt, das den Tabellennamen, die Spaltennamen und die Datentypen der Spalten angibt.

Der Code im folgenden Beispiel erstellt ein Table-Objekt, das eine Tabelle mit dem Namen my_table mit den angegebenen Spalten darstellt:

from snowflake.core.table import Table, TableColumn

my_table = Table(
  name="my_table",
  columns=[TableColumn(name="c1", datatype="int", nullable=False),
           TableColumn(name="c2", datatype="string")]
)
root.databases["my_db"].schemas["my_schema"].tables.create(my_table)
Copy

Der Code erstellt dann die Tabelle in der Datenbank my_db und im Schema my_schema, indem das Table-Objekt an die Methode TableCollection.create übergeben wird.

Abrufen von Tabellendetails

Sie können Informationen zu einer Tabelle erhalten, indem Sie die Methode TableResource.fetch aufrufen, die ein Table-Objekt zurückgibt.

Der Code im folgenden Beispiel ruft Informationen über eine Tabelle mit dem Namen my_table ab:

my_table = root.databases["my_db"].schemas["my_schema"].tables["my_table"].fetch()
print(my_table.to_dict())
Copy

Erstellen oder Ändern einer Tabelle

Sie können Eigenschaften eines Table-Objekts festlegen und es an die TableResource.create_or_alter-Methode übergeben, um eine Tabelle zu erstellen, wenn sie nicht existiert, oder sie entsprechend der Definition der Tabelle zu ändern, wenn sie existiert. Die Verhaltensweise von create_or_alter soll idempotent sein, was bedeutet, dass das resultierende Tabellenobjekt dasselbe ist, unabhängig davon, ob die Tabelle bereits vor der Ausführung der Methode existiert.

Bemerkung

Die create_or_alter-Methode verwendet Standardwerte für alle Eigenschaften der Tabelle https://docs.snowflake.com/en/developer-guide/snowflake-python-api/reference/latest/_autosummary/snowflake.core.table.Table, die Sie nicht explizit definieren. Wenn Sie z. B. data_retention_time_in_days nicht einstellen, wird der Wert auf None voreingestellt, auch wenn die Tabelle zuvor mit einem anderen Wert existierte.

Der Code im folgenden Beispiel fügt der my_table-Tabelle eine neue Spalte mit dem Namen c3 vom Datentyp int hinzu und ändert dann die Tabelle in Snowflake:

from snowflake.core.table import PrimaryKey, TableColumn

my_table = root.databases["my_db"].schemas["my_schema"].tables["my_table"].fetch()
my_table.columns.append(TableColumn(name="c3", datatype="int", nullable=False, constraints=[PrimaryKey()]))

my_table_res = root.databases["my_db"].schemas["my_schema"].tables["my_table"]
my_table_res.create_or_alter(my_table)
Copy

Auflisten von Tabellen

Sie können die Tabellen eines bestimmten Schemas mit der Methode iter auflisten, die einen Iterator PagedIter für Table-Objekte zurückgibt.

Der Code im folgenden Beispiel listet Tabellen auf, deren Name mit my beginnt:

tables = root.databases["my_db"].schemas["my_schema"].tables.iter(like="my%")
for table_obj in tables:
  print(table_obj.name)
Copy

Löschen einer Tabelle

Sie können eine Tabelle mit der TableResource.drop-Methode löschen.

Der Code im folgenden Beispiel löscht die my_table-Tabelle:

my_table_res = root.databases["my_db"].schemas["my_schema"].tables["my_table"]
my_table_res.drop()
Copy

Verwalrten von Ereignistabellen

Sie können Snowflake-Ereignistabellen verwalten, die eine spezielle Art von Datenbanktabelle mit einer vordefinierten Anzahl von Spalten sind, in denen Snowflake-Telemetriedaten sammeln kann. Weitere Informationen dazu finden Sie unter Überblick über die Ereignisse.

Die Snowflake Python APIs stellt Ereignistabellen mit zwei verschiedenen Typen dar:

  • EventTable: Zeigt die Eigenschaften einer Ereignistabelle an, z. B. den Namen, die Datenaufbewahrungsdauer, die maximale Dauer der Erweiterung und die Option zur Änderungsverfolgung.

  • EventTableResource: Stellt Methoden zur Verfügung, mit denen Sie ein entsprechendes EventTable-Objekt abrufen, die Ereignistabelle umbenennen und die Ereignistabelle löschen können.

Themen

Erstellen einer Ereignistabelle

Um eine Ereignistabelle zu erstellen, legen Sie zunächst ein EventTable- Objekt an und erstellen dann ein EventTableCollection-Objekt aus dem API Root-Objekt. Fügen Sie mit EventTableCollection.create die neue Ereignistabelle zu Snowflake hinzu.

Der Code im folgenden Beispiel erstellt ein EventTable-Objekt, das eine Ereignistabelle mit dem Namen my_event_table mit den angegebenen Parametern darstellt:

from snowflake.core.event_table import EventTable

event_table = EventTable(
  name="my_event_table",
  data_retention_time_in_days = 3,
  max_data_extension_time_in_days = 5,
  change_tracking = True,
  default_ddl_collation = 'EN-CI',
  comment = 'CREATE EVENT TABLE'
)

event_tables = root.databases["my_db"].schemas["my_schema"].event_tables
event_tables.create(my_event_table)
Copy

Der Code erstellt eine EventTableCollection-Variable event_tables und verwendet EventTableCollection.create, um eine neue Ereignistabelle in Snowflake zu erstellen.

Abrufen von Details zu Ereignissen

Sie können Informationen über eine Ereignistabelle erhalten, indem Sie die EventTableResource.fetch-Methode aufrufen, die ein EventTable-Objekt zurückgibt.

Der Code im folgenden Beispiel ruft Informationen über eine Ereignistabelle mit dem Namen my_event_table ab:

my_event_table = root.databases["my_db"].schemas["my_schema"].event_tables["my_event_table"].fetch()
print(my_event_table.to_dict())
Copy

Auflistung von Ereignistabellen

Sie können Ereignistabellen mit der EventTableCollection.iter-Methode auflisten, die einen PagedIter-Iterator von EventTable-Objekten zurückgibt.

Der Code im folgenden Beispiel listet Ereignistabellen auf, deren Name mit my in der my_db-Datenbank und im my_schema-Schema beginnt, und gibt den Namen jeder Tabelle aus:

from snowflake.core.event_table import EventTableCollection

event_tables: EventTableCollection = root.databases["my_db"].schemas["my_schema"].event_tables
event_table_iter = event_tables.iter(like="my%")  # returns a PagedIter[EventTable]
for event_table_obj in event_table_iter:
  print(event_table_obj.name)
Copy

Der Code im folgenden Beispiel listet ebenfalls Ereignistabellen auf, deren Name mit my beginnt, verwendet aber den starts_with-Parameter anstelle von like. In diesem Beispiel wird auch der optionale show_limit=10-Parameter eingestellt, um die Anzahl der Ergebnisse auf 10 zu beschränken:

event_tables: EventTableCollection = root.databases["my_db"].schemas["my_schema"].event_tables
event_table_iter = event_tables.iter(starts_with="my", show_limit=10)
for event_table_obj in event_table_iter:
  print(event_table_obj.name)
Copy

Durchführen von Operationen der Ereignistabelle

Sie können gängige Operationen für Ereignistabellen - wie das Umbenennen einer Ereignistabelle und das Löschen einer Ereignistabelle - mit einem EventTableResource-Objekt durchführen.

Bemerkung

Derzeit wird nur die RENAME-Funktion von ALTER TABLE (Ereignistabellen) unterstützt.

RENAME wird in der Standard-Ereignistabelle nicht unterstützt, SNOWFLAKE.TELEMETRY.EVENTS.

Zur Veranschaulichung der Operationen, die Sie mit einer Ressource für Ereignistabellen durchführen können, wird der Code im folgenden Beispiel wie folgt ausgeführt:

  1. Ruft das Ressourcenobjekt der my_event_table-Ereignistabelle ab.

  2. Benennt die Ereignistabelle um.

  3. Löscht die Ereignistabelle.

my_event_table_res = root.databases["my_db"].schemas["my_schema"].event_tables["my_event_table"]

my_event_table_res.rename("my_other_event_table")
my_event_table_res.drop()
Copy

Verwalrten von Ansichten

Sie können Ansichten in Snowflake verwalten. Eine Ansicht ist ein Objekt auf Schema-Ebene und ermöglicht den Zugriff auf das Ergebnis einer Abfrage, als wäre es eine Tabelle. Wenn Sie eine Ansicht erstellen oder referenzieren, tun Sie dies im Kontext des zugehörigen Schemas.

Bemerkung

ALTER VIEW wird derzeit nicht unterstützt.

Die Snowflake Python APIs stellt Ansichten mit zwei verschiedenen Typen dar:

  • View: Zeigt die Eigenschaften einer Ansicht an, z. B. ihren Namen, Spalten und die SQL-Abfrageanweisung.

  • ViewResource: Stellt Methoden zur Verfügung, mit denen Sie ein entsprechendes View-Objekt abrufen und die Ansicht löschen können.

Themen

Erstellen einer Ansicht

Um eine Ansicht zu erstellen, erstellen Sie zunächst ein View-Objekt, das den Namen der Ansicht, die Spalten und die SQL-Abfrage-Anweisung angibt.

Der Code im folgenden Beispiel erstellt ein View-Objekt, das eine Ansicht mit dem Namen my_view mit den angegebenen Spalten und der SQL-Abfrage darstellt:

from snowflake.core.view import View, ViewColumn

my_view = View(
  name="my_view",
  columns=[
      ViewColumn(name="c1"), ViewColumn(name="c2"), ViewColumn(name="c3"),
  ],
  query="SELECT * FROM my_table",
)

root.databases["my_db"].schemas["my_schema"].views.create(my_view)
Copy

Der Code erstellt dann die Ansicht in der my_db-Datenbank und im my_schema-Schema, indem er das View-Objekt an die ViewCollection.create-Methode übergibt.

Abrufen von Ansichtsdetails

Sie können Informationen über eine Ansicht erhalten, indem Sie die ViewResource.fetch-Methode aufrufen, die ein View-Objekt zurückgibt.

Der Code im folgenden Beispiel ruft ein View-Objekt ab, das die my_view-Ansicht darstellt:

my_view = root.databases["my_db"].schemas["my_schema"].views["my_view"].fetch()
print(my_view.to_dict())
Copy

Anzeige der Freigabeangebote

Sie können die Ansichten in einer bestimmten Datenbank mit der iter-Methode auflisten. Die Methode gibt einen PagedIter-Iterator für View-Objekte zurück.

Der Code im folgenden Beispiel listet die Ansichten auf, deren Name mit my in der my_db-Datenbank und dem my_schema-Schema beginnt:

view_list = root.databases["my_db"].schemas["my_schema"].views.iter(like="my%")
for view_obj in view_list:
  print(view_obj.name)
Copy

Der Code im folgenden Beispiel listet auch Ansichten auf, deren Name mit my beginnt, verwendet aber den starts_with-Parameter anstelle von like. In diesem Beispiel wird auch der optionale show_limit=10-Parameter eingestellt, um die Anzahl der Ergebnisse auf 10 zu beschränken:

view_list = root.databases["my_db"].schemas["my_schema"].views.iter(starts_with="my", show_limit=10)
for view_obj in view_list:
  print(view_obj.name)
Copy

Eine Ansicht löschen

Sie können eine Ansicht mit der ViewResource.drop-Methode ablegen.

Der Code im folgenden Beispiel lässt die my_view-Ansicht verschwinden:

my_view_res = root.databases["my_db"].schemas["my_schema"].views["my_view"]
my_view_res.drop()
Copy