Gestion des bases de données, schémas, tables et vues Snowflake avec Python

Vous pouvez utiliser Python pour gérer les bases de données, schémas, tables et vues Snowflake. Pour plus d’informations sur la gestion et l’utilisation des données dans Snowflake, voir Bases de données, tables et vues - Vue d’ensemble.

Conditions préalables

Les exemples de cette rubrique supposent que vous ayez ajouté le code nécessaire pour vous connecter à Snowflake et créer un objet Root à partir duquel utiliser les Snowflake Python APIs.

Par exemple, le code suivant utilise les paramètres de connexion définis dans un fichier de configuration pour créer une connexion à Snowflake.

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

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

En utilisant l’objet Session obtenu, le code crée un objet Root pour utiliser les types et les méthodes de l’API. Pour plus d’informations, voir Connexion à Snowflake avec Snowflake Python APIs.

Gestion des bases de données

Vous pouvez gérer des bases de données dans Snowflake. Les Snowflake Python APIs représentent des bases de données avec deux types distincts :

  • Database : expose les propriétés d’une base de données telles que son nom.

  • DatabaseResource : expose des méthodes que vous pouvez utiliser pour extraire un objet Database correspondant et pour supprimer la base de données.

Sujets

Création d’une base de données

Vous pouvez créer une base de données en appelant la méthode DatabaseCollection.create et en lui transmettant un objet Database représentant la base de données que vous souhaitez créer. Pour créer une base de données, commencez par créer un objet Database qui spécifie le nom de la base de données.

Le code de l’exemple suivant crée un objet Database représentant une base de données nommée my_db puis crée la base de données en transmettant l’objet Database à la méthode DatabaseCollection.create :

from snowflake.core.database import Database

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

Obtention de détails de la base de données

Vous pouvez obtenir des informations sur une base de données en appelant la méthode DatabaseResource.fetch, qui renvoie un objet Database.

Le code de l’exemple suivant permet d’obtenir des informations sur une base de données nommée my_db :

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

Répertorier des bases de données

Vous pouvez répertorier les bases de données en utilisant la méthode iter, qui renvoie un itérateur PagedIter.

Le code de l’exemple suivant répertorie les bases de données dont le nom commence par my :

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

Suppression d’une base de données

Vous pouvez supprimer une base de données via la méthode DatabaseResource.drop.

Le code dans l’exemple suivant supprime la base de données my_db :

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

Gestion des schémas

Vous pouvez gérer les schémas dans Snowflake. Un schéma est un objet au niveau de la base de données. Lorsque vous créez ou référencez un schéma, vous le faites dans le contexte de sa base de données.

Les Snowflake Python APIs représentent des schémas avec deux types distincts :

  • Schema : expose les propriétés d’un schéma telles que son nom.

  • SchemaResource : expose des méthodes que vous pouvez utiliser pour extraire un objet Schema correspondant et pour supprimer le schéma.

Sujets

Création d’un schéma

Pour créer un schéma, commencez par créer un objet Schema qui spécifie le nom du schéma.

Le code de l’exemple suivant crée un objet Schema représentant un schéma nommé my_schema :

from snowflake.core.schema import Schema

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

Le code crée ensuite le schéma dans la base de données my_db en transmettant l’objet Schema à la méthode SchemaCollection.create.

Obtention de détails sur le schéma

Vous pouvez obtenir des informations sur un schéma en appelant la méthode SchemaResource.fetch, qui renvoie un objet Schema.

Le code de l’exemple suivant permet d’obtenir un objet Schema qui représente le schéma my_schema :

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

Répertorier les schémas

Vous pouvez répertorier les schémas d’une base de données spécifiée via la méthode iter. La méthode renvoie un itérateur PagedIter d’objets Schema.

Le code de l’exemple suivant répertorie les noms des schémas de la base de données my_db :

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

Suppression d’un schéma

Vous pouvez supprimer un schéma via la méthode SchemaResource.drop.

Le code dans l’exemple suivant supprime le schéma my_schema :

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

Gestion des tables standards

Vous pouvez gérer des tables standards dans Snowflake. Une table est un objet au niveau du schéma. Lorsque vous créez ou référencez une table, vous le faites dans le contexte de son schéma.

Les Snowflake Python APIs représentent des tables avec deux types distincts :

  • Table : expose les propriétés d’une table telles que son nom et ses colonnes.

  • TableResource : expose des méthodes que vous pouvez utiliser pour extraire un objet Table correspondant, mettre à jour les propriétés de la table et supprimer la table.

Sujets

Création d’une table

Pour créer une table, commencez par créer un objet Table qui spécifie le nom de la table, les noms de colonne et les types de données des colonnes.

Le code de l’exemple suivant crée un objet Table représentant une table nommée my_table avec les colonnes spécifiées :

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

Le code crée ensuite la table dans la base de données my_db et le schéma my_schema en transmettant l’objet Table à la méthode TableCollection.create.

Obtention des détails d’une table

Vous pouvez obtenir des informations sur une table en appelant la méthode TableResource.fetch, qui renvoie un objet Table.

Le code de l’exemple suivant permet d’obtenir des informations sur une table nommée my_table :

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

Création ou modification d’une table

Vous pouvez définir les propriétés d’un objet Table et le transmettre à la méthode TableResource.create_or_alter pour créer une table si elle n’existe pas, ou la modifier selon la définition de la table si elle existe. Le comportement de create_or_alter est censé être idempotent, ce qui signifie que l’objet de table résultant sera le même, que la table existe ou non avant l’exécution de la méthode.

Note

La méthode create_or_alter utilise des valeurs par défaut pour toute propriété de table que vous ne définissez pas explicitement. Par exemple, si vous ne définissez pas data_retention_time_in_days, sa valeur par défaut est None même si la table existait auparavant avec une valeur différente.

Le code de l’exemple suivant ajoute une nouvelle colonne nommée c3 de type de données int à la table my_table, puis modifie la table dans 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

Répertorier les tables

Vous pouvez répertorier les tables d’un schéma spécifié en utilisant la méthode iter, qui renvoie un itérateur PagedIter d’objets Table.

Le code de l’exemple suivant répertorie les tables dont le nom commence par my :

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

Suppression d’une table

Vous pouvez supprimer une table via la méthode TableResource.drop.

Le code dans l’exemple suivant supprime la table my_table :

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

Gestion des tables d’événements

Vous pouvez gérer les tables d’événements Snowflake, qui sont un type spécial de table de base de données avec un ensemble prédéfini de colonnes où Snowflake peut collecter des données de télémétrie. Pour plus d’informations, voir Aperçu de la table d’événements.

Les Snowflake Python APIs représentent des tables d’événements avec deux types distincts :

  • EventTable : expose les propriétés d’une table d’événements telles que son nom, la durée de conservation des données, la durée maximale d’extension des données et l’option de suivi des modifications.

  • EventTableResource : expose les méthodes que vous pouvez utiliser pour récupérer un objet EventTable correspondant, renommer la table des événements et supprimer la table des événements.

Sujets

Création d’une table d’événements

Pour créer une table d’événements, il faut d’abord créer un objet EventTable, puis créer un objet EventTableCollection à partir de l’objet Root de l’API. En utilisant EventTableCollection.create, ajoutez la nouvelle table d’événements à Snowflake.

Le code de l’exemple suivant crée un objet EventTable qui représente une table d’événements nommée my_event_table avec les paramètres spécifiés :

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

Ce code crée une variable EventTableCollection event_tables et utilise EventTableCollection.create pour créer une nouvelle table d’événements dans Snowflake.

Obtenir les détails de la table des événements

Vous pouvez obtenir des informations sur une table d’événements en appelant la méthode EventTableResource.fetch, qui renvoie un objet EventTable.

Le code de l’exemple suivant obtient des informations sur une table d’événements nommée my_event_table :

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

Affichage des tables d’événements

Vous pouvez répertorier des tables d’événements à l’aide de la méthode EventTableCollection.iter qui renvoie un itérateur PagedIter d’objets EventTable.

Le code de l’exemple suivant répertorie les tables d’événements dont le nom commence par my dans la base de données my_db et le schéma my_schema, et imprime le nom de chacun :

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

Le code de l’exemple suivant répertorie également les tables d’événements dont le nom commence par my, mais il utilise le paramètre starts_with au lieu de like. Cet exemple définit également le paramètre facultatif show_limit=10 pour limiter le nombre de résultats à 10 :

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

Exécution d’opérations sur la table d’événements

Vous pouvez effectuer des opérations courantes sur les tables d’événements, telles que renommer une table d’événements et supprimer une table d’événements, avec un objet EventTableResource.

Note

Seule la fonctionnalité RENAME de ALTER TABLE (tables d’événements) est actuellement prise en charge.

RENAME n’est pas pris en charge sur la table d’événements par défaut, SNOWFLAKE.TELEMETRY.EVENTS.

Pour illustrer les opérations que vous pouvez effectuer avec une ressource de table d’événements, le code de l’exemple suivant effectue les opérations suivantes :

  1. Extrait l’objet de ressource de table d’événements my_event_table.

  2. Renomme la table d’événements.

  3. Supprime la table d’événements.

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

Gestion des vues

Vous pouvez gérer les vues dans Snowflake. Une vue est un objet de niveau schéma et permet d’accéder au résultat d’une requête comme s’il s’agissait d’une table. Lorsque vous créez ou faites référence à une vue, vous le faites dans le contexte de son schéma.

Note

ALTER VIEW n’est actuellement pas pris en charge.

Les Snowflake Python APIs représentent des vues avec deux types distincts :

  • View : expose les propriétés d’une vue, telles que son nom, ses colonnes et une instruction de requête SQL.

  • ViewResource : expose des méthodes que vous pouvez utiliser pour extraire un objet View correspondant et pour supprimer le schéma.

Sujets

Création d’une vue

Pour créer une vue, créez d’abord un objet View qui spécifie le nom de la vue, les colonnes et l’instruction de requête SQL.

Le code de l’exemple suivant crée un objet View représentant une vue nommée my_view avec les colonnes et la requête SQL spécifiées :

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

Le code crée ensuite la vue dans la base de données my_db et le schéma my_schema en transmettant l’objet View à la méthode ViewCollection.create.

Obtenir les détails de la vue

Vous pouvez obtenir des informations sur une vue en appelant la méthode ViewResource.fetch, qui renvoie un objet View.

Le code de l’exemple suivant permet d’obtenir un objet View qui représente la vue my_view :

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

Affichage des vues

Vous pouvez répertorier les vues d’une base de données spécifiée via la méthode iter. La méthode renvoie un itérateur PagedIter d’objets View.

Le code de l’exemple suivant répertorie les vues dont le nom commence par my dans la base de données my_db et le schéma my_schema :

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

Le code de l’exemple suivant répertorie également les vues dont le nom commence par my, mais il utilise le paramètre starts_with au lieu de like. Cet exemple définit également le paramètre facultatif show_limit=10 pour limiter le nombre de résultats à 10 :

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

Suppression d’une vue

Vous pouvez supprimer une vue en utilisant la méthode ViewResource.drop.

Le code dans l’exemple suivant supprime la vue my_view :

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