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)
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 objetDatabase
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)
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 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()
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 objetSchema
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)
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 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()
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 objetTable
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)
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’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)
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)
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()
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 objetEventTable
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)
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
.
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 :
Extrait l’objet de ressource de table d’événements
my_event_table
.Renomme la table d’événements.
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()
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 objetView
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)
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()