Exécution d’instructions SQL¶

Utilisation de variables pour les modèles SQL¶

Dans certaines situations, vous pouvez souhaiter modifier vos requêtes SQL en fonction du contexte. La commande snow sql prend en charge la substitution de variables côté client, ce qui vous permet d’utiliser des variables dans la commande qui sont résolues localement avant de soumettre la requête. Les variables de la chaîne SQL prennent la forme <% variable_name %>, et l’option -D (ou --variable) spécifie la valeur de la variable.

Note

Vous pouvez actuellement utiliser la syntaxe SnowSQL &variable_name et <% variable_name %> pour les modèles. Cependant, Snowflake recommande d’utiliser la <% variable_name %>.

Par exemple, pour spécifier une base de données à l’aide d’une variable côté client, vous pouvez entrer une commande similaire à la suivante :

snow sql -q "select * from <% database %>.logs" -D "database=dev"

Lorsqu’elle est exécutée, la commande remplace la valeur dev dans la variable <% database %> pour créer le nom de fichier dev.logs, puis envoie la requête select * from dev.logs SQL à Snowflake en vue de son traitement.

Vous pouvez également spécifier plusieurs entrées variables, comme indiqué :

snow sql \
-q "grant usage on database <% database %> to <% role %>" \
-D "database=dev" \
-D "role=eng_rl"

Cet exemple génère la requête SQL suivante :

grant usage on database dev to eng_rl

Stockage de variables dans le fichier de définition du projet snowflake.yml¶

Il n’est pas toujours pratique de spécifier des variables en tant qu’options de ligne de commande snow sql, ou vous ne souhaitez peut-être pas spécifier des valeurs sensibles sur la ligne de commande. Dans ce cas, vous pouvez définir des variables et des valeurs dans le fichier de définition du projet snowflake.yml. Vous pouvez alors spécifier les noms des variables sous la forme <% ctx.env.<variable_name> %> au lieu d’utiliser l’option -D "<variable> = <valeur>".

En reprenant l’exemple de la section précédente, vous pourriez stocker la base de données et les variables de rôle dans le fichier snowflake.yml et modifier la requête ainsi :

snow sql -q "grant usage on database <% ctx.env.database %> to <% ctx.env.role %>"

Dans cet exemple, la commande snow sql recherche les définitions de variables dans le fichier de définition du projet et extrait les valeurs sans les rendre visibles sur la ligne de commande. Le fichier snowflake.yml doit être situé soit dans le répertoire de travail actuel, soit à l’emplacement spécifié avec l’option -p.

Pour plus d’informations sur l’enregistrement de ces valeurs dans le fichier de définition du projet, voir Utiliser des variables dans SQL.

Exécution asynchrone des requêtes SQL¶

Snowflake CLI vous permet d’exécuter une ou plusieurs requêtes SQL de manière asynchrone. Au lieu d’attendre un résultat, la commande snow sql planifie les requêtes au niveau de Snowflake et renvoie un ID de requête. Une fois la requête terminée, vous pouvez obtenir le résultat en utilisant la commande de requête !result ou la commande SQL RESULT_SCAN.

Pour exécuter une requête SQL de manière asynchrone, terminez la requête par ; > au lieu de ;, comme indiqué :

snow sql -q 'select "My async query" ;>'

L’exemple suivant exécute une seule requête de manière asynchrone :

snow sql -q "select 'This is async query';>"

select 'This is async query'
+--------------------------------------+
| scheduled query ID                   |
|--------------------------------------|
| 01bc3011-080f-f2d7-0001-c1be14bae7c2 |
+--------------------------------------+

Vous pouvez ensuite utiliser l’ID de requête renvoyée dans la commande de requête !result pour afficher le résultat de la requête :

snow sql -q '!result 01bc3011-080f-f2d7-0001-c1be14bae7c2'

path-to-private-key-file
+-----------------------+
| 'THIS IS ASYNC QUERY' |
|-----------------------|
| This is async query   |
+-----------------------+

Vous pouvez également exécuter plusieurs requêtes dans la chaîne de requête, à la fois de manière asynchrone et synchrone, comme indiqué :

snow sql -q "select 'This is async query';> select 'Not an async query'; select 'Another async query';>"

select 'This is async query'
+--------------------------------------+
| scheduled query ID                   |
|--------------------------------------|
| 01bc3b8c-0109-2e81-0000-0f2d0e5a4a32 |
+--------------------------------------+

select 'Not an async query';
+----------------------+
| 'NOT AN ASYNC QUERY' |
|----------------------|
| Not an async query   |
+----------------------+

select 'Another async query'
+--------------------------------------+
| scheduled query ID                   |
|--------------------------------------|
| 01bc3b8c-0109-2e81-0000-0f2d0e5a4a36 |
+--------------------------------------+

Utilisation des commandes de requête SQL¶

Snowflake CLI fournit les commandes suivantes que vous pouvez utiliser dans vos requêtes SQL :

• !source, qui exécute SQL dans les fichiers locaux ou les URLs.

• !queries, qui répertorie toutes les requêtes SQL.

• !result, qui affiche le résultat d’une requête SQL.

• !abort, qui annule une requête SQL active.

snow sql -q '!source my_sql_code.sql'

select emp_id FROM employees;
!source code_file_2.sql

snow sql -q '!result 01bc3011-080f-f2d7-0001-c1be14bae7c2'

+-----------------------+
| 'THIS IS ASYNC QUERY' |
|-----------------------|
| This is async query   |
+-----------------------+

snow sql -q '!abort 01bc3011-080f-f2d7-0001-c1be14bae7c2'

+-------------------------------------------------------------+
| SYSTEM$CANCEL_QUERY('01BC3011-080F-F2D7-0001-C1BE14BAE7C2') |
|-------------------------------------------------------------|
| Identified SQL statement is not currently executing.        |
+-------------------------------------------------------------+

Saisie de plusieurs commandes dans une même transaction¶

L’option --single-transaction vous permet de saisir plusieurs commandes SQL à exécuter comme un ensemble de commandes « tout ou rien ». En exécutant les commandes dans une seule transaction, vous pouvez vous assurer que toutes les commandes ont été exécutées avec succès avant de valider les modifications. Si l’une des commandes échoue, aucune des modifications apportées par les commandes abouties n’est maintenue.

Les exemples suivants montrent des transactions abouties et non abouties :

• Exécution de commande aboutie

  snow sql -q "insert into my_tbl values (123); insert into my_tbl values (124);" --single-transaction
  

  Copy

  BEGIN;
  +----------------------------------+
  | status                           |
  |----------------------------------|
  | Statement executed successfully. |
  +----------------------------------+
  
  insert into my_tbl values (123);
  +-------------------------+
  | number of rows inserted |
  |-------------------------|
  | 1                       |
  +-------------------------+
  
  insert into my_tbl values (124);
  +-------------------------+
  | number of rows inserted |
  |-------------------------|
  | 1                       |
  +-------------------------+
  
  COMMIT
  +----------------------------------+
  | status                           |
  |----------------------------------|
  | Statement executed successfully. |
  +----------------------------------+
  

  Vous pouvez alors vérifier que les commandes ont été validées dans la base de données :

  snow sql -q "select count(*) from my_tbl"
  

  Copy

  select count(*) from my_tbl
  +----------+
  | COUNT(*) |
  |----------|
  | 2        |
  +----------+
  

• Transaction unique infructueuse

  snow sql -c patcli -q "insert into my_tbl values (123); insert into my_tbl values (124); select BAD;" --single-transaction
  

  Copy

  BEGIN;
  +----------------------------------+
  | status                           |
  |----------------------------------|
  | Statement executed successfully. |
  +----------------------------------+
  
  insert into my_tbl values (123);
  +-------------------------+
  | number of rows inserted |
  |-------------------------|
  | 1                       |
  +-------------------------+
  
  insert into my_tbl values (124);
  +-------------------------+
  | number of rows inserted |
  |-------------------------|
  | 1                       |
  +-------------------------+
  
  select BAD;
  ╭─ Error ───────────────────────────────────────────────────────────────────────────────╮
  │ 000904 (42000): 01bc3b84-0810-0247-0001-c1be14ee11ce: SQL compilation error: error    │
  │ line 1 at position 7                                                                  │
  │ invalid identifier 'BAD'                                                              │
  ╰───────────────────────────────────────────────────────────────────────────────────────╯
  

Vous pouvez alors vérifier que les commandes n’ont pas été validées dans la base de données :

snow sql -q "select count(*) from my_tbl"

Copy

select count(*) from my_tbl
+----------+
| COUNT(*) |
|----------|
| 0        |
+----------+

Saisie de commandes SQL en mode interactif¶

La commande snow sql prend en charge un mode interactif qui vous permet de saisir des commandes SQL une par une. Le mode interactif offre les fonctions suivantes :

• Mise en évidence de la syntaxe

  

• Complétion du code lors de la frappe

  

• Historique consultable

  En appuyant sur CTRL-R: vous pouvez effectuer une recherche dans l’historique de vos commandes :

  

• Entrée multilignes

  En appuyant sur ENTER sur une ligne qui ne se termine pas par un point-virgule (;), le curseur passe à la ligne suivante pour d’autres commandes jusqu’à ce qu’une instruction se termine par un point-virgule.

  

Pour utiliser le mode interactif, entrez la commande snow sql, suivie de ENTER, comme indiqué :

snow sql

La commande ouvre un sous-interpréteur avec une invite > où vous pouvez entrer des commandes SQL de manière interactive :

$ snow sql
  ╭───────────────────────────────────────────────────────────────────────────────────╮
  │ Welcome to Snowflake-CLI REPL                                                     │
  │ Type 'exit' or 'quit' to leave                                                    │
  ╰───────────────────────────────────────────────────────────────────────────────────╯
  >

Vous pouvez ensuite entrer les commandes SQL, comme indiqué :

> create table my_table (c1 int);

+-------------------------------------+
| status                              |
|-------------------------------------|
| Table MY_TABLE successfully created.|
+-------------------------------------+

Pour quitter le mode interactif, entrez exit, quit, ou CTRL-D.