Snowflake en 20 minutes

Introduction

Ce tutoriel utilise le client de ligne de commande de Snowflake SnowSQL pour présenter les concepts et tâches clés, dont :

  • Création d’objets Snowflake — Vous créez une base de données et une table pour stocker les données.

  • Chargement des données — Nous fournissons de petits échantillons de fichiers de données CSV que vous pouvez charger dans la table.

  • Requête—Vous explorez des exemples de requêtes.

Note

Snowflake nécessite un entrepôt virtuel pour charger les données et exécuter les requêtes. Un entrepôt virtuel actif consomme des crédits Snowflake. Cependant, le nombre de crédits consommés dans ce tutoriel est minime, car vous pouvez terminer l’intégralité du tutoriel en moins de 30 minutes. En outre, Snowflake facture un montant minimal pour le stockage sur disque utilisé pour les données d’exemple dans ce tutoriel. Cependant, ce tutoriel fournit des étapes pour supprimer la table et réduire le coût de stockage. Si vous utilisez un compte d’essai de 30 jours, le compte fournit des crédits gratuits et vous n’encourrez aucun coût. Pour plus d’informations sur la taille et le coût des entrepôts, consultez Taille d’entrepôt.

Ce que vous apprendrez

Dans ce tutoriel, vous apprendrez à :

  • Créer des objets Snowflake — Vous créez une base de données et une table, pour stocker les données.

  • Installer SnowSQL — Vous installez et utilisez SnowSQL, l’outil d’interrogation en ligne de commande de Snowflake.

    Les utilisateurs de Visual Studio Code pourraient envisager d’utiliser Snowflake Extension for Visual Studio Code au lieu de SnowSQL.

  • Charger des fichiers de données CSV — Vous utilisez divers mécanismes pour charger les données dans les tables à partir de fichiers CSV.

  • Rédiger et exécuter des exemples de requêtes — Vous rédigez et exécutez une série de requêtes sur des données nouvellement chargées.

Conditions préalables

Ce tutoriel nécessite une base de données, une table et un entrepôt virtuel pour charger et interroger les données. La création de ces objets Snowflake nécessite un utilisateur Snowflake ayant un rôle avec les privilèges de contrôle d’accès nécessaires. De plus, SnowSQL est nécessaire pour exécuter les instructions SQL dans le tutoriel. Pour terminer, le tutoriel nécessite des fichiers CSV qui contiennent des données d’échantillon à charger.

Vous pouvez effectuer ce tutoriel à l’aide d’un entrepôt, d’une base de données et d’une table Snowflake existants et de vos propres fichiers de données locaux. Cependant, nous vous recommandons d’utiliser les objets Snowflake et l’ensemble des données fournies.

Pour configurer Snowflake pour ce tutoriel, effectuez les opérations suivantes avant de continuer :

  1. Créer un utilisateur

    Pour créer la base de données, la table et l’entrepôt virtuel, vous devez être connecté en tant qu’utilisateur Snowflake avec un rôle qui vous accorde les privilèges nécessaires pour créer ces objets.

    • Si vous utilisez un compte d’essai de 30 jours, vous pouvez vous connecter en tant qu’utilisateur créé pour ce compte. Cet utilisateur a le rôle avec les privilèges nécessaires pour créer les objets.

    • Si vous n’avez pas d’utilisateur Snowflake, vous ne pouvez pas effectuer ce tutoriel. Si vous n’avez pas de rôle vous permettant de créer un utilisateur, demandez à quelqu’un qui en a un d’effectuer cette étape pour vous. Les utilisateurs avec le rôle ACCOUNTADMIN ou SECURITYADMIN peuvent créer des utilisateurs.

  2. Installer SnowSQL

    Pour installer SnowSQL, voir Installation de SnowSQL.

  3. Téléchargement des fichiers de données d’exemple

    Pour ce tutoriel, vous téléchargez des exemples de fichiers de données d’employés au format CSV fournis par Snowflake.

    Pour télécharger et décompresser les fichiers de données d’exemple :

    1. Téléchargez l’ensemble des fichiers de données d’échantillon. Cliquez avec le bouton droit de la souris sur le nom du fichier d’archive getting-started.zip, et enregistrez le lien/le fichier dans votre système de fichiers local.

    2. Décompressez les fichiers d’exemple. Le tutoriel suppose que vous avez décompressé les fichiers dans l’un des répertoires suivants :

    • Linux/macOS : /tmp

    • Windows : C:\\temp

    Chaque fichier comporte cinq enregistrements de données. Les données utilisent le caractère virgule (,) comme délimiteur de champ. Voici un exemple d’enregistrement :

    Althea,Featherstone,afeatherstona@sf_tuts.com,"8172 Browning Street, Apt B",Calatrava,7/12/2017
    
    Copy

Il n’y a pas d’espaces blancs avant ou après les virgules séparant les champs dans chaque enregistrement. Il s’agit de la valeur par défaut attendue par Snowflake lors du chargement des données CSV.

Se connecter à SnowSQL

Une fois que vous avez SnowSQL, démarrez SnowSQL pour vous connecter à Snowflake :

  1. Ouvrez une fenêtre de ligne de commande.

  2. Démarrez SnowSQL :

    $ snowsql -a <account_identifier> -u <user_name>
    
    Copy

    Où :

    Note

    Si votre compte dispose d’un fournisseur d’identité (IdP) qui a été défini pour votre compte, vous pouvez utiliser un navigateur Web pour vous authentifier au lieu d’un mot de passe, comme le montre l’exemple suivant :

    $ snowsql -a <account_identifier> -u <user_name> --authenticator externalbrowser
    
    Copy

    Pour plus d’informations, voir Utilisation d’un navigateur Web pour l’authentification fédérée/SSO.

  3. Lorsque SnowSQL vous y invite, saisissez le mot de passe de votre utilisateur Snowflake.

Si vous vous connectez avec succès, SnowSQL affiche une invite de commande qui comprend votre entrepôt, votre base de données et votre schéma actuels.

Note

Si votre compte est verrouillé et que vous ne pouvez pas obtenir l’identificateur du compte, vous pouvez le trouver dans l’e-mail de bienvenue que Snowflake vous a envoyé lors de votre inscription au compte d’essai. Vous pouvez aussi travailler avec votre ORGADMIN pour obtenir les détails du compte. Vous pouvez également trouver les valeurs de locator, cloud, et region dans l’e-mail de bienvenue.

Si votre utilisateur Snowflake n’a pas d’entrepôt, de base de données et de schéma par défaut, ou si vous n’avez pas configuré SnowSQL pour spécifier un entrepôt, une base de données et un schéma par défaut, l’invite affiche no warehouse, no database et no schema. Par exemple :

user-name#(no warehouse)@(no database).(no schema)>
Copy

Cette invite indique qu’il n’y a pas d’entrepôt, de base de données et de schéma sélectionnés pour la session en cours. Vous créez ces objets à l’étape suivante. Lorsque vous suivez les étapes suivantes de ce tutoriel pour créer ces objets, l’invite est automatiquement mise à jour pour inclure les noms de ces objets.

Pour plus d’informations, voir Connexion par le biais de SnowSQL.

Créer des objets Snowflake

Dans cette étape, vous créez les objets Snowflake suivants :

  • Une base de données (sf_tuts) et une table (emp_basic). Vous chargez des données d’exemple dans cette table.

  • Un entrepôt virtuel (sf_tuts_wh). Cet entrepôt fournit les ressources de calcul nécessaires au chargement des données dans la table et à l’interrogation de la table. Pour ce tutoriel, vous créez un entrepôt X-Small.

Lorsque vous aurez terminé ce tutoriel, vous supprimerez ces objets.

Créer une base de données

Créez la base de données sf_tuts en utilisant la commande CREATE DATABASE :

CREATE OR REPLACE DATABASE sf_tuts;
Copy

Dans ce tutoriel, vous utilisez le schéma par défaut (public) disponible pour chaque base de données, plutôt que de créer un nouveau schéma.

Notez que la base de données et le schéma que vous venez de créer sont maintenant utilisés pour votre session en cours, comme en témoigne l’invite de commande SnowSQL. Vous pouvez également utiliser les fonctions contextuelles pour obtenir ces informations.

SELECT CURRENT_DATABASE(), CURRENT_SCHEMA();
Copy

Voici un exemple de résultat :

+--------------------+------------------+
| CURRENT_DATABASE() | CURRENT_SCHEMA() |
|--------------------+------------------|
| SF_TUTS            | PUBLIC           |
+--------------------+------------------+

Créer une table

Créez une table nommée emp_basic dans sf_tuts.public en utilisant la commande CREATE TABLE :

CREATE OR REPLACE TABLE emp_basic (
   first_name STRING ,
   last_name STRING ,
   email STRING ,
   streetaddress STRING ,
   city STRING ,
   start_date DATE
   );
Copy

Notez que le nombre de colonnes de la table, leurs positions et leurs types de données correspondent aux champs des fichiers de données d’échantillon CSV que vous échelonnez dans l’étape suivante de ce tutoriel.

Créer un entrepôt virtuel

Créez un entrepôt de très petite taille nommé sf_tuts_wh en utilisant la commande CREATE WAREHOUSE :

CREATE OR REPLACE WAREHOUSE sf_tuts_wh WITH
   WAREHOUSE_SIZE='X-SMALL'
   AUTO_SUSPEND = 180
   AUTO_RESUME = TRUE
   INITIALLY_SUSPENDED=TRUE;
Copy

L’entrepôt sf_tuts_wh est initialement suspendu, mais l’instruction DML définit également AUTO_RESUME = true. Le paramètre AUTO_RESUME fait en sorte qu’un entrepôt démarre automatiquement lorsque des instructions SQL nécessitant des ressources de calcul sont exécutées.

Une fois l’entrepôt créé, il est utilisé pour la session actuelle. Ces informations sont affichées dans votre invite de commande SnowSQL. Vous pouvez également récupérer le nom de l’entrepôt en utilisant la fonction contextuelle suivante :

SELECT CURRENT_WAREHOUSE();
Copy

Voici un exemple de résultat :

+---------------------+
| CURRENT_WAREHOUSE() |
|---------------------|
| SF_TUTS_WH          |
+---------------------+

Fichiers de données en zone de préparation

Une zone de préparation Snowflake est un emplacement dans un stockage Cloud que vous utilisez pour charger et décharger les données d’une table. Snowflake prend en charge les types de zones de préparation suivants :

  • Zones de préparation internes — Utilisées pour stocker les fichiers de données en interne dans Snowflake. Chaque utilisateur et chaque table dans Snowflake dispose par défaut d’une zone de préparation interne pour la mise en zone de préparation des fichiers de données.

  • Zones de préparation externes — Utilisées pour stocker des fichiers de données en externe dans Amazon S3, Google Cloud Storage ou Microsoft Azure. Si vos données sont déjà stockées dans ces services de stockage dans le Cloud, vous pouvez utiliser une zone de préparation externe pour charger les données dans des tables Snowflake.

Dans ce tutoriel, nous chargeons les fichiers de données d’exemple (téléchargés dans Conditions préalables) vers la zone de préparation interne pour la table emp_basic que vous avez créée précédemment. Vous utilisez la commande PUT pour charger les fichiers de données suivants vers cette zone de préparation.

Mise en zone de préparation de fichiers de données d’exemple

Exécutez la commande PUT dans SnowSQL pour charger les fichiers de données locaux vers la zone de préparation de table fournie pour la table emp_basic que vous avez créée.

PUT file://<file-path>[/\]employees0*.csv @sf_tuts.public.%emp_basic;
Copy

Par exemple :

  • Linux ou macOS

    PUT file:///tmp/employees0*.csv @sf_tuts.public.%emp_basic;
    
    Copy
  • Windows

    PUT file://C:\temp\employees0*.csv @sf_tuts.public.%emp_basic;
    
    Copy

Regardons la commande de plus près :

  • file://<file-path>[/\]employees0*.csv spécifie le chemin complet du répertoire et les noms des fichiers sur votre machine locale vers la zone de préparation. Notez que les caractères génériques du système de fichiers sont autorisés et que si plusieurs fichiers correspondent au modèle, ils sont tous affichés.

  • @<espace_noms>.%<nom_table> indique d’utiliser la zone de préparation pour la table spécifiée, dans ce cas la table emp_basic .

La commande renvoie le résultat suivant, montrant les fichiers en zone de préparation :

+-----------------+--------------------+-------------+-------------+--------------------+--------------------+----------+---------+
| source          | target             | source_size | target_size | source_compression | target_compression | status   | message |
|-----------------+--------------------+-------------+-------------+--------------------+--------------------+----------+---------|
| employees01.csv | employees01.csv.gz |         360 |         287 | NONE               | GZIP               | UPLOADED |         |
| employees02.csv | employees02.csv.gz |         355 |         274 | NONE               | GZIP               | UPLOADED |         |
| employees03.csv | employees03.csv.gz |         397 |         295 | NONE               | GZIP               | UPLOADED |         |
| employees04.csv | employees04.csv.gz |         366 |         288 | NONE               | GZIP               | UPLOADED |         |
| employees05.csv | employees05.csv.gz |         394 |         299 | NONE               | GZIP               | UPLOADED |         |
+-----------------+--------------------+-------------+-------------+--------------------+--------------------+----------+---------+

La commande PUT compresse les fichiers par défaut en utilisant gzip comme indiqué dans la colonne TARGET_COMPRESSION.

Création d’une liste de fichiers en zone de préparation (facultatif)

Vous pouvez lister les fichiers en zone de préparation en utilisant la commande LIST.

LIST @sf_tuts.public.%emp_basic;
Copy

Voici un exemple de résultat :

+--------------------+------+----------------------------------+------------------------------+
| name               | size | md5                              | last_modified                |
|--------------------+------+----------------------------------+------------------------------|
| employees01.csv.gz |  288 | a851f2cc56138b0cd16cb603a97e74b1 | Tue, 9 Jan 2018 15:31:44 GMT |
| employees02.csv.gz |  288 | 125f5645ea500b0fde0cdd5f54029db9 | Tue, 9 Jan 2018 15:31:44 GMT |
| employees03.csv.gz |  304 | eafee33d3e62f079a054260503ddb921 | Tue, 9 Jan 2018 15:31:45 GMT |
| employees04.csv.gz |  304 | 9984ab077684fbcec93ae37479fa2f4d | Tue, 9 Jan 2018 15:31:44 GMT |
| employees05.csv.gz |  304 | 8ad4dc63a095332e158786cb6e8532d0 | Tue, 9 Jan 2018 15:31:44 GMT |
+--------------------+------+----------------------------------+------------------------------+

Copier des données dans les tables cibles

Pour charger vos données en zone de préparation dans la table cible, exécutez COPY INTO <table>.

La commande COPY INTO <table> utilise l’entrepôt virtuel que vous avez créé dans Créer des objets Snowflake pour copier les fichiers.

COPY INTO emp_basic
  FROM @%emp_basic
  FILE_FORMAT = (type = csv field_optionally_enclosed_by='"')
  PATTERN = '.*employees0[1-5].csv.gz'
  ON_ERROR = 'skip_file';
Copy

Où :

  • La clause FROM spécifie l’emplacement contenant les fichiers de données (la zone de préparation interne de la table).

  • La clause FILE_FORMAT spécifie le type de fichier comme CSV, et spécifie le caractère de guillemet double (") comme caractère utilisé pour fermer les chaînes. Snowflake prend en charge différents types de fichier et options. Vous trouverez une description dans CREATE FILE FORMAT.

  • La clause PATTERN spécifie que la commande doit charger les données à partir des noms de fichiers correspondant à cette expression régulière (.*employees0[1-5].csv.gz).

  • La clause ON_ERROR spécifie ce qu’il faut faire lorsque la commande COPY rencontre des erreurs dans les fichiers. Par défaut, la commande arrête le chargement des données à la première erreur rencontrée. Cet exemple ignore tout fichier contenant une erreur et passe au chargement du fichier suivant. (Aucun des fichiers de ce tutoriel ne contient d’erreurs, il ne s’agit que d’une illustration.)

La commande COPY propose également une option permettant de valider les fichiers avant de les charger. Pour plus d’informations sur les vérifications d’erreurs supplémentaires et la validation , voir les chapitres COPY INTO <table> et les autres tutoriels sur le chargement des données.

La commande COPY renvoie un résultat indiquant la liste des fichiers copiés et les informations connexes :

+--------------------+--------+-------------+-------------+-------------+-------------+-------------+------------------+-----------------------+-------------------------+
| file               | status | rows_parsed | rows_loaded | error_limit | errors_seen | first_error | first_error_line | first_error_character | first_error_column_name |
|--------------------+--------+-------------+-------------+-------------+-------------+-------------+------------------+-----------------------+-------------------------|
| employees02.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees04.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees05.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees03.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees01.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
+--------------------+--------+-------------+-------------+-------------+-------------+-------------+------------------+-----------------------+-------------------------+

Interrogation des données chargées

Vous pouvez interroger les données chargées dans la table emp_basic à l’aide d’un code SQL standard et des fonctions et opérateurs pris en charge.

Vous pouvez également manipuler les données, par exemple mettre à jour les données chargées ou ajouter des données supplémentaires à l’aide de commandes DML standard.

Récupérer toutes les données

Retournez l’ensemble des lignes et colonnes de la table :

SELECT * FROM emp_basic;
Copy

Voici un résultat partiel :

+------------+--------------+---------------------------+-----------------------------+--------------------+------------+
| FIRST_NAME | LAST_NAME    | EMAIL                     | STREETADDRESS               | CITY               | START_DATE |
|------------+--------------+---------------------------+-----------------------------+--------------------+------------|
| Arlene     | Davidovits   | adavidovitsk@sf_tuts.com  | 7571 New Castle Circle      | Meniko             | 2017-05-03 |
| Violette   | Shermore     | vshermorel@sf_tuts.com    | 899 Merchant Center         | Troitsk            | 2017-01-19 |
| Ron        | Mattys       | rmattysm@sf_tuts.com      | 423 Lien Pass               | Bayaguana          | 2017-11-15 |
 ...
 ...
 ...
| Carson     | Bedder       | cbedderh@sf_tuts.co.au    | 71 Clyde Gallagher Place    | Leninskoye         | 2017-03-29 |
| Dana       | Avory        | davoryi@sf_tuts.com       | 2 Holy Cross Pass           | Wenlin             | 2017-05-11 |
| Ronny      | Talmadge     | rtalmadgej@sf_tuts.co.uk  | 588 Chinook Street          | Yawata             | 2017-06-02 |
+------------+--------------+---------------------------+-----------------------------+--------------------+------------+
Copy

Insérer des lignes de données supplémentaires

Outre charger des données à partir de fichiers préparés dans une table, vous pouvez insérer des lignes directement dans une table en utilisant la commande INSERT DML.

Par exemple, pour insérer deux lignes supplémentaires dans la table :

INSERT INTO emp_basic VALUES
   ('Clementine','Adamou','cadamou@sf_tuts.com','10510 Sachs Road','Klenak','2017-9-22') ,
   ('Marlowe','De Anesy','madamouc@sf_tuts.co.uk','36768 Northfield Plaza','Fangshan','2017-1-26');
Copy

Lignes de requête basées sur l’adresse e-mail

Retournez une liste d’adresses e-mail avec des domaines de haut niveau du Royaume-Uni en utilisant la fonction LIKE :

SELECT email FROM emp_basic WHERE email LIKE '%.uk';
Copy

Voici un exemple de résultat :

+--------------------------+
| EMAIL                    |
|--------------------------|
| gbassfordo@sf_tuts.co.uk |
| rtalmadgej@sf_tuts.co.uk |
| madamouc@sf_tuts.co.uk   |
+--------------------------+

Lignes de requête basées sur la date de début

Par exemple, pour calculer la date de début de certains avantages d’employé, ajoutez 90 jours aux dates de début d’employé à l’aide de la fonction DATEADD. Filtrez la liste par employé dont la date de début est antérieure au 1er janvier 2017 :

SELECT first_name, last_name, DATEADD('day',90,start_date) FROM emp_basic WHERE start_date <= '2017-01-01';
Copy

Voici un exemple de résultat :

+------------+-----------+------------------------------+
| FIRST_NAME | LAST_NAME | DATEADD('DAY',90,START_DATE) |
|------------+-----------+------------------------------|
| Granger    | Bassford  | 2017-03-30                   |
| Catherin   | Devereu   | 2017-03-17                   |
| Cesar      | Hovie     | 2017-03-21                   |
| Wallis     | Sizey     | 2017-03-30                   |
+------------+-----------+------------------------------+

Résumé, nettoyage et ressources supplémentaires

Félicitations ! Vous avez terminé avec succès ce tutoriel d’introduction.

Prenez quelques minutes pour passer en revue un bref résumé et les points clés abordés dans le tutoriel. Vous pouvez également envisager un nettoyage en détruisant tous les objets que vous avez créés dans le tutoriel. Pour en savoir plus, consultez les autres rubriques de la documentation Snowflake.

Résumé et points clés

En résumé, le chargement des données se fait en deux étapes :

  1. Préparez des fichiers de données à charger. Les fichiers peuvent être préparés en interne (dans Snowflake) ou en externe. Dans ce tutoriel, vous mettez des fichiers en zone de préparation en interne.

  2. Copiez les données des fichiers en zone de préparation dans une table cible existante. Un entrepôt en cours d’exécution est nécessaire pour cette étape.

Rappelez-vous les points clés suivants concernant le chargement des fichiers CSV :

  • Un fichier CSV est constitué d’un ou plusieurs enregistrements, avec un ou plusieurs champs dans chaque enregistrement, et parfois un enregistrement d’en-tête.

  • Les enregistrements et les champs de chaque fichier sont séparés par des délimiteurs. Les délimiteurs par défaut sont les suivants :

    Enregistrements

    Caractères de nouvelle ligne

    Champs

    Virgules

    En d’autres termes, Snowflake s’attend à ce que chaque enregistrement d’un fichier CSV soit séparé par de nouvelles lignes et que les champs (c.-à-d. les valeurs individuelles) de chaque enregistrement soient séparés par des virgules. Si différents caractères sont utilisés comme délimiteurs d’enregistrement et de champ, vous devez explicitement le spécifier comme faisant partie du format du fichier lors du chargement.

  • Il y a une corrélation directe entre les champs des fichiers et les colonnes de la table que vous allez charger, en ce qui concerne :

    • Le nombre de champs (dans le fichier) et de colonnes (dans la table cible).

    • Les positions des champs et des colonnes dans leur fichier/table respectif.

    • Les types de données, tels que chaîne de caractères, numéro ou date pour les champs et les colonnes.

    Les enregistrements ne seront pas chargés si les nombres, les positions et les types de données ne correspondent pas aux données.

    Note

    Snowflake prend en charge le chargement de fichiers dont les champs ne sont pas exactement alignés avec les colonnes de la table cible. Cependant, il s’agit d’un sujet de chargement de données plus avancé (abordé dans la section Transformation des données pendant un chargement).

Tutoriel Nettoyage (facultatif)

Si les objets que vous avez créés dans ce tutoriel ne sont plus nécessaires, vous pouvez les supprimer du système à l’aide des instructions DROP <objet>.

DROP DATABASE IF EXISTS sf_tuts;

DROP WAREHOUSE IF EXISTS sf_tuts_wh;
Copy

Quitter la connexion

Pour quitter une connexion, utilisez la commande !exit pour SnowSQL (ou son alias, !disconnect).

Abandonne la connexion actuelle et quitte SnowSQL s’il s’agit de la dernière connexion.

Quelle est la prochaine étape ?

Continuez à vous renseigner sur Snowflake à l’aide des ressources suivantes :