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

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)

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

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)

Suppression ou restauration d’une base de données¶

Vous pouvez supprimer une base de données à l’aide de la méthode DatabaseResource.drop ou restaurer une base de données à l’aide de la méthode DatabaseResource.undrop.

Pour illustrer ces opérations, le code de l’exemple suivant supprime puis restaure la version la plus récente de la base de données my_db :

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

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)

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

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)

Suppression ou restauration d’un schéma¶

Vous pouvez supprimer un schéma à l’aide de la méthode SchemaResource.drop ou restaurer un schéma à l’aide de la méthode SchemaResource.undrop.

Pour illustrer ces opérations, le code de l’exemple suivant supprime puis restaure la version la plus récente du schéma my_schema :

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

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)

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

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’appel de la méthode.

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)

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)

Échange de noms de tables¶

Vous pouvez échanger le nom d’une table avec celui d’une autre table en une seule transaction à l’aide de la méthode TableResource.swap_with. Pour plus d’informations, voir la description du paramètre SWAPWITH dans la ALTER TABLE.

Le code de l’exemple suivant échange my_table avec other_table dans la même base de données et le même schéma :

my_table_res = root.databases["my_db"].schemas["my_schema"].tables["my_table"]
my_table_res.swap_with("other_table")

Le code de l’exemple suivant échange my_table (dans la base de données my_db et le schéma my_schema) avec other_table (dans la base de données other_db et le schéma other_schema) :

my_table_res = root.databases["my_db"].schemas["my_schema"].tables["my_table"]
my_table_res.swap_with(to_swap_table_name="other_table", target_database="other_db", target_schema="other_schema")

Effectuer des opérations sur les tables¶

Vous pouvez effectuer des opérations courantes sur les tables, telles que la gestion et le reclustering d’une table et la suppression ou la restauration d’une table, à l’aide d’un objet TableResource.

Pour plus d’informations sur ces opérations de table, voir Commandes de tables, de vues et de séquences dans la référence de la commande SQL.

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

1. Obtient l’objet ressource de la table my_table dans la base de données my_db et le schéma my_schema.

2. Suspend le reclustering pour la table.

3. Reprend le reclustering pour la table.

4. Supprime la table.

5. Restaure la version la plus récente de la table supprimée.

my_table_res = root.databases["my_db"].schemas["my_schema"].tables["my_table"]

my_table_res.suspend_recluster()
my_table_res.resume_recluster()
my_table_res.drop()
my_table_res.undrop()

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)

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

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)

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)

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.

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. Obtient l’objet ressource de la table des événements my_event_table dans la base de données my_db et le schéma my_schema.

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

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)

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

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)

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)

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