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

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)

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

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)

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

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)

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

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)

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

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)

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

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.

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)

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)

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

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)

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

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)

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)

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.

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

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)

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

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)

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)

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