Utilisation de SnowSQL

Ce chapitre décrit l’utilisation de SnowSQL, y compris le démarrage et l’arrêt du client, l’utilisation des commandes et des variables dans le client, et fournit d’autres informations générales d’utilisation.

Dans ce chapitre :

Exécution de commandes

Dans une session Snowflake, vous pouvez exécuter des commandes pour prendre des mesures spécifiques. Toutes les commandes dans SnowSQL commencent par un point d’exclamation (!) suivi du nom de la commande.

Par exemple :

user#> !help

+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+
| Command    | Use                                       | Aliases     | Description                                                                                |
|------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------|
| !abort     | !abort <query id>                         |             | Abort a query                                                                              |
| !connect   | !connect <connection_name>                |             | Create a new connection                                                                    |
| !define    | !define <variable>=<value>                |             | Define a variable as the given value                                                       |
| !edit      | !edit <query>                             |             | Opens up a text editor. Useful for writing longer queries. Defaults to last query          |
| !exit      | !exit                                     | !disconnect | Drop the current connection                                                                |
| !help      | !help                                     | !helps, !h  | Show the client help.                                                                      |
| !options   | !options                                  | !opts       | Show all options and their values                                                          |
| !pause     | !pause                                    |             | Pauses running queries.                                                                    |
| !print     | !print <message>                          |             | Print given text                                                                           |
| !queries   | !queries help, <filter>=<value>, <filter> |             | Lists queries matching the specified filters. Write <!queries> help for a list of filters. |
| !quit      | !quit                                     | !q          | Drop all connections and quit SnowSQL                                                      |
| !rehash    | !rehash                                   |             | Refresh autocompletion                                                                     |
| !result    | !result <query id>                        |             | See the result of a query                                                                  |
| !set       | !set <option>=<value>                     |             | Set an option to the given value                                                           |
| !source    | !source <filename>, <url>                 | !load       | Execute given sql file                                                                     |
| !spool     | !spool <filename>, off                    |             | Turn on or off writing results to file                                                     |
| !system    | !system <system command>                  |             | Run a system command in the shell                                                          |
| !variables | !variables                                | !vars       | Show all variables and their values                                                        |
+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+

Pour une description détaillée de chaque commande, voir Référence Commandes (dans ce chapitre).

Utilisation de variables

Vous pouvez utiliser des variables pour stocker et réutiliser des valeurs dans une session Snowflake. Les variables vous permettent d’utiliser des valeurs définies par l’utilisateur et des valeurs de base de données dans les requêtes.

Vous pouvez définir des variables pour SnowSQL de plusieurs façons :

  • Dans le fichier de configuration (avant de se connecter à Snowflake).

  • En utilisant des paramètres de connexion (lors de la connexion à Snowflake).

  • En exécutant des commandes (sur la ligne de commande de la session Snowflake).

De plus, vous pouvez substituer des variables dans une session. Snowflake fournit des variables intégrées.

Définition avant la connexion (fichier de configuration)

Pour définir des variables avant de se connecter à Snowflake, ajoutez les variables dans le fichier de configuration config.

  1. Ouvrez le fichier de configuration config dans un éditeur de texte. L’emplacement par défaut du fichier est :

    Linux/macOS

    ~/.snowsql/

    Windows

    %USERPROFILE%\.snowsql\

    Note

    Vous pouvez spécifier un emplacement différent en incluant le paramètre de connexion --config <chemin> au démarrage de SnowSQL.

  2. Ajoutez des variables dans la section [variables] :

    [variables]
    <variable_name>=<variable_value>
    

    Où :

    • <nom_variable> est une chaîne de caractères alphanumériques (insensible à la casse) représentant le nom de la variable.

    • <valeur_variable> est une chaîne de caractères représentant la valeur de la variable. Si nécessaire, la chaîne peut être entourée de guillemets simples ou doubles.

    Par exemple :

    [variables]
    tablename=CENUSTRACKONE
    

Définition pendant la connexion (paramètre de connexion -D ou --variable)

Pour définir des variables lors de la connexion à Snowflake, sur la ligne de commande de terminal, spécifiez les paramètres de connexion -D ou --variable suivis par le nom et la valeur de la variable, sous la forme suivante : <nom_variable>=<valeur_variable>.

Par exemple :

Linux/macOS
$ snowsql ... -D tablename=CENUSTRACKONE --variable db_key=$DB_KEY
Windows
$ snowsql ... -D tablename=CENUSTRACKONE --variable db_key=%DB_KEY%

Dans l’exemple ci-dessus :

  • -D définit une variable nommée tablename sur CENUSTRACKONE.

  • --variable affecte une variable Snowflake nommée db_key à la variable d’environnement DB_KEY.

Définition dans une session (commande !define)

Pour définir une variable après la connexion à Snowflake, exécutez la commande !define dans la session.

Par exemple :

user#> !define tablename=CENUSTRACKONE

Substitution dans une session

Si l’option de configuration variable_substitution est activée, les variables définies peuvent être référencées dans SnowSQL avec leurs valeurs substituées par des requêtes en utilisant la syntaxe &<variable>. Les références de variable sont insensibles à la casse.

Par exemple :

user#> !define snowshell=bash

user#> !set variable_substitution=true

user#> select '&snowshell';

+--------+
| 'BASH' |
|--------|
| bash   |
+--------+

Si variable_substitution est désactivé, aucune substitution de variable ne se produit.

Par exemple :

user#> !define snowshell=bash

user#> !set variable_substitution=false

user#> select '&snowshell';

+--------------+
| '&SNOWSHELL' |
|--------------|
| &snowshell   |
+--------------+

De plus, si l’option variable_substitution est activée, mais qu’aucune variable n’est définie, SnowSQL affiche une erreur.

Pour combiner une variable avec du texte, placez la référence de variable entre accolades.

Par exemple :

user#> !define snowshell=bash

user#> !set variable_substitution=true

select '&{snowshell}_shell';

+--------------+
| 'BASH_SHELL' |
|--------------|
| bash_shell   |
+--------------+

Pour utiliser une esperluette sans utiliser de substitution, isolez l’esperluette avec à l’aide d’une deuxième esperluette.

&&<variable>

Par exemple :

user#> !set variable_substitution=true

user#> select '&notsubstitution';

Variable notsubstitution is not defined

user#> select '&&notsubstitution';

+--------------------+
| '&NOTSUBSTITUTION' |
|--------------------|
| &notsubstitution   |
+--------------------+

Note

Il n’y a actuellement aucune option pour annuler la définition d’une valeur d’option, telle que l’option variable_substitution. Pour modifier la valeur d’une option, exécutez à nouveau la commande !set avec la valeur souhaitée.

Variables intégrées

SnowSQL inclut un ensemble de variables intégrées qui renvoient des métadonnées sur les instructions exécutées dans la session utilisateur en cours.

Chacun de ces noms de variable commence par deux tirets bas (« __ »).

__rowcount

Renvoie le nombre de lignes affectées par la dernière instruction DML exécutée par l’utilisateur.

user#> insert into a values(1),(2),(3);

+-------------------------+
| number of rows inserted |
|-------------------------|
|                       3 |
+-------------------------+
3 Row(s) produced. Time Elapsed: 0.950s

user#> !set variable_substitution=true

user#> select &__rowcount;

+---+
| 3 |
|---|
| 3 |
+---+
__sfqid

Renvoie l’ID de la requête la plus récente exécutée par l’utilisateur.

user#> !set variable_substitution=true

user#> select * from a;

user#> select '&__sfqid';

+----------------------------------------+
| 'A5F35B56-49A2-4437-BA0E-998496CE793E' |
|----------------------------------------|
| a5f35b56-49a2-4437-ba0e-998496ce793e   |
+----------------------------------------+

Utilisation de l’auto-complétion

Plusieurs fonctions SQL, noms de table et variables sont stockés dans SnowSQL et sont automatiquement complétés en mode interactif. Pour sélectionner une suggestion d’auto-complétion, appuyez sur la touche [Tab]. Pour choisir une autre suggestion, utilisez les touches [flèche vers le haut] et [flèche vers le bas] pour sélectionner l’option désirée, puis appuyez sur [Tab].

Pour désactiver l’auto-complétion interactivement, réglez l’option de configuration auto_completion sur False dans le fichier de configuration.

Affichage de l’historique de votre ligne de commande

L’historique récent de votre ligne de commande peut être rappelé à l’aide de la touche [flèche vers le haut]. Appuyez plusieurs fois sur la touche pour faire défiler la mémoire tampon.

Fichier Historique

Le fichier historique interactif de ligne de commande est nommé history et se trouve dans ~/.snowsql/history.

Exécution de scripts par lots

Vous pouvez exécuter des scripts par lots de deux façons :

  • En utilisant des paramètres de connexion (lors de la connexion à Snowflake).

  • En exécutant des commandes (sur la ligne de commande de la session Snowflake).

Exécution pendant la connexion (paramètre de connexion -f)

Pour exécuter un script SQL en se connectant à Snowflake, utilisez le paramètre de connexion -f <nom_fichier_entrée> :

Un fichier de sortie pour le script peut être spécifié en utilisant -o output_file=<nom_fichier_sortie>. De plus, vous pouvez utiliser -o quiet=true pour désactiver la sortie standard et -o friendly=false pour désactiver les messages de démarrage et de sortie.

Par exemple :

snowsql -a xy12345 -u jsmith -f /tmp/input_script.sql -o output_file=/tmp/output.csv -o quiet=true -o friendly=false -o header=false -o output_format=csv

Pour plus d’informations sur tous les paramètres de connexion, voir Référence Paramètres de connexion.

Exécution dans une session (commande !source ou !load)

Pour exécuter un script SQL après la connexion à Snowflake, exécutez la commande !source (ou !load) dans la session.

Par exemple :

user#> !source example.sql

Exportation de données

Sortie des résultats de la requête vers un fichier dans un format défini en suivant les options de configuration suivantes :

  • output_format=format_sortie

  • output_file=nom_fichier_sortie

Pour supprimer le texte de garde, le texte d’en-tête, le calendrier et le message d’au revoir de la sortie, définissez également les options suivantes :

  • friendly=false

  • header=false

  • timing=false

Comme pour toutes les options de configuration, vous pouvez les définir à l’aide de l’une des méthodes suivantes :

  • Dans le fichier de configuration (avant de se connecter à Snowflake).

  • En utilisant le paramètre de connexion -o ou --options (lors de la connexion à Snowflake).

  • En exécutant la commande !set (sur la ligne de commande dans la session Snowflake).

Notez que les requêtes consécutives sont ajoutées au fichier de sortie. Autrement, pour rediriger la sortie de requête vers un fichier et écraser le fichier par chaque nouvelle instruction, utilisez le signe supérieur à (>) dans un script.

Dans l’exemple suivant, SnowSQL se connecte à un compte en utilisant une connexion nommée et interroge une table. La sortie est écrite dans un fichier CSV nommé output_file.csv dans le répertoire local actuel :

Linux/macOS

snowsql -c my_example_connection -d sales_db -s public -q 'select * from mytable limit 10' -o output_format=csv -o header=false -o timing=false -o friendly=false  > output_file.csv
Windows

snowsql -c my_example_connection -d sales_db -s public -q "select * from mytable limit 10" -o output_format=csv -o header=false -o timing=false -o friendly=false  > output_file.csv

Modification du format d’invite SnowSQL

L’invite SnowSQL affiche dynamiquement des informations de contexte sur la session en cours :

  • Lorsque vous vous connectez à Snowflake, l’invite affiche votre nom d’utilisateur, ainsi que l’entrepôt, la base de données et le schéma par défaut (si des valeurs par défaut ont été définies).

  • Si vous utilisez une commande USE dans la session pour définir ou modifier l’entrepôt, la base de données ou le schéma, l’invite change pour refléter le contexte.

Vous pouvez contrôler l’apparence et la structure de l’invite à l’aide de l’option de configuration prompt_format et d’un jeton Pygments entre parenthèses pour chaque type d’objet sous forme de [jetons] (p. ex. [user] ou [warehouse]).

Le jeton affecte l’invite et celle d’après, et ainsi de suite. Vous pouvez changer l’ordre et la couleur de chaque jeton, ainsi que les délimiteurs entre les jetons.

Comme pour toutes les options de configuration, vous pouvez définir l’invite en utilisant l’une des méthodes suivantes :

  • Dans le fichier de configuration (avant de se connecter à Snowflake).

  • En utilisant le paramètre de connexion -o ou --options (lors de la connexion à Snowflake).

  • En exécutant la commande !set (sur la ligne de commande dans la session Snowflake).

Note

Si vous modifiez l’invite à l’aide du paramètre de connexion ou directement sur la ligne de commande, la modification s’applique uniquement à la session en cours. Pour maintenir le changement dans les sessions futures, définissez l’option dans le fichier de configuration.

Jetons pris en charge

SnowSQL prend en charge les types d’objet suivants en tant que jeton :

  • user

  • account

  • role

  • database

  • schema

  • warehouse

Invite par défaut

L’invite par défaut SnowSQL utilise les jetons et la structure suivant :

[user]#[warehouse]@[database].[schema]>

Par exemple :

marie#DATALOAD@DEMO_DB.PUBLIC>

Exemple d’invite

Pour poursuivre l’exemple ci-dessus, la commande !set suivante exécutée dans la ligne de commande change l’ordre des jetons en user, database et schema, puis warehouse. Elle modifie également le délimiteur de chaque jeton par un point (.) et définit les jetons de façon à utiliser différentes couleurs :

marie#DATALOAD@DEMO_DB.PUBLIC> !set prompt_format=[#FF0000][user].[#00FF00][database].[schema].[#0000FF][warehouse]>

Cet exemple donne lieu à l’invite suivante pour la session :

SnowSQL prompt format

Déconnexion de Snowflake et arrêt de SnowSQL

SnowSQL fournit des commandes séparées pour :

  • Quitter les connexions individuelles (c’est-à-dire les sessions) sans arrêter SnowSQL.

  • Quitter SnowSQL, qui met automatiquement fin à toutes les connexions.

Pour quitter une connexion/session, utilisez la commande !exit (ou son alias, !disconnect). Vous pouvez ensuite vous reconnecter en utilisant !connect <nom_connexion> si vous pouvez définir plusieurs connexions dans le fichier SnowSQL config . Notez que, si vous n’avez qu’une seule connexion ouverte, la commande !exit quitte/arrête également SnowSQL.

Pour quitter toutes les connexions puis quitter/arrêter SnowSQL, utilisez la commande !quit (ou son alias, !q). Vous pouvez également saisir [CTRL]-d sur votre clavier.

Codes de sortie

Il existe plusieurs codes de sortie possibles qui sont renvoyés lorsque SnowSQL se ferme.

0

Tout s’est bien passé.

1

Une erreur est survenue avec le client.

2

Une erreur est survenue avec les arguments de ligne de commande.

3

SnowSQL n’a pas pu contacter le serveur.

4

SnowSQL n’a pas pu communiquer correctement avec le serveur.

5

L’option de configuration exit_on_error a été définie et SnowSQL s’est fermé à cause d’une erreur.

Raccourcis clavier par défaut

[Tab]

Accepter la suggestion d’auto-complétion actuel.

[CTRL]-d

Quitter/arrêter SnowSQL.

Référence Commandes

!abort

Annule une requête (spécifiée par l’ID de requête). L’ID de requête peut être obtenu à partir de la page History History tab dans l’interface Web.

Par exemple :

user#> !abort 77589bd1-bcbf-4ec8-9ebc-6c949b00614d;

!connect

SnowSQL prend en charge les sessions multiples (c’est-à-dire les connexions) avec !connect <nom_connexion> :

  • Les paramètres/options de connexion associés à nom_connexion sont stockés dans la section [connections.<nom_connexion>] correspondante du fichier de configuration SnowSQL.

  • Si un paramètre/option n’est pas spécifié dans la section [connections.<nom_connexion>] , le paramètre non spécifié correspondra par défaut aux paramètres dans [connections].

Lorsque vous vous connectez, la connexion est ajoutée à votre pile de connexions, et le fait de quitter vous ramènera à votre connexion précédente. Quitter fermera toutes vos connexions, quel que soit le nombre de connexions que vous avez.

Par exemple :

Fichier de configuration :

[connections.my_example_connection]
...

Ligne de commande :

user#> !connect my_example_connection

!define

Définit une variable sur une valeur spécifiée, en utilisant le format suivant :

!define <nom_variable>=<valeur_variable>

Le nom et la valeur doivent être séparés par un seul = sans espaces. Les caractères valides qui peuvent être utilisés dans la variable sont les suivants :

0-9a-zA-Z\_

!edit

Ouvre l’éditeur qui a été configuré à l’aide du paramètre de connexion editor (si aucun éditeur n’a été configuré, la valeur par défaut est vim). La commande accepte une requête comme argument. Si aucun argument n’est passé, cela ouvre la dernière requête qui a été exécutée.

Note

Vous devez effectuez une sauvegarde avant ou au moment de quitter l’éditeur, sinon tout texte saisi/modifié dans l’éditeur ne sera pas sauvegardé.

!exit , !disconnect

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

!help , !helps , !h

Affiche l’aide pour les commandes SnowSQL.

!options , !opts

Renvoie une liste de toutes les options de configuration SnowSQL et leurs valeurs actuellement définies. Ces options peuvent être définies à l’aide de la commande !set dans la session SnowSQL actuelle.

Note

Ces options peuvent également être définies dans le fichier de configuration pour SnowSQL ou en tant que paramètres de connecteur dans la ligne de commande lorsque SnowSQLest appelé.

!pause

Mettez en pause les requêtes en cours. Appuyez sur la touche Retour pour continuer.

!print

Imprime le texte spécifié à l’écran et tous les fichiers vers lesquels vous effectuez un « spooling ».

Par exemple :

user#> !print Include This Text

!queries

Répertorie toutes les requêtes qui correspondent aux filtres spécifiés. Les filtres par défaut sont session et amount=25 qui renvoient les 25 requêtes les plus récentes de la session en cours.

Par exemple :

  • Renvoie les 25 requêtes les plus récentes qui ont été exécutées dans la session en cours :

    !queries session
    
  • Renvoie les 20 requêtes les plus récentes exécutées dans le compte :

    !queries amount=20
    
  • Renvoie les 20 requêtes les plus récentes exécutées dans le compte qui ont pris plus de 200 millisecondes à s’exécuter :

    !queries amount=20 duration=200
    
  • Renvoie les 25 requêtes les plus récentes qui se sont exécutées dans l’entrepôt spécifié :

    !queries warehouse=mywh
    

Cette commande crée une variable pour chaque ID de requête renvoyé. Notez que la substitution de variable doit être activée pour que vous puissiez utiliser ces variables. Par exemple :

user#> !queries session

+-----+--------------------------------------+----------+-----------+----------+
| VAR | QUERY ID                             | SQL TEXT | STATUS    | DURATION |
|-----+--------------------------------------+----------+-----------+----------|
| &0  | acbd6778-c68c-4e79-a977-510b2d8c08f1 | select 1 | SUCCEEDED |       19 |
+-----+--------------------------------------+----------+-----------+----------+

user#> !result &0

+---+
| 1 |
|---|
| 1 |
+---+

user#> !result acbd6778-c68c-4e79-a977-510b2d8c08f1

+---+
| 1 |
|---|
| 1 |
+---+

!quit , !q (aussi [CTRL]-d)

Abandonne toutes les connexions et quitte SnowSQL.

!rehash

Resynchronise les jetons d’auto-complétion.

Une utilisation normale ne nécessite pas de resynchroniser les jetons d’auto-complétion. Cependant, forcer une mise à jour des jetons côté serveur pourrait être utile dans certains scénarios (par exemple, si une nouvelle fonction définie par l’utilisateur est créée dans une session différente).

!result

Renvoie le résultat d’une requête complétée (spécifié par l’ID de requête). Les IDs de requête peuvent être obtenus à partir de la page History History tab dans l’interface Web ou via la commande !queries.

Si la requête est toujours en cours d’exécution, la commande attend que la requête soit terminée.

Par exemple :

user#> !result 77589bd1-bcbf-4ec8-9ebc-6c949b00614d;

!set

Définit l’option de configuration spécifiée SnowSQL sur une valeur donnée au format <option>=<valeur>.

Notez qu’il n’existe actuellement aucune option servant à annuler la définition d’une valeur d’option. Pour modifier la valeur d’une option, exécutez à nouveau la commande !set avec la valeur souhaitée.

Par exemple :

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 1000              |
 ...
+-----------------------+-------------------+

user#> !set rowset_size=500

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 500               |
 ...
+-----------------------+-------------------+

user#> !set rowset_size=1000

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 1000              |
 ...
+-----------------------+-------------------+

Important

Les espaces ne sont pas autorisés entre une option et sa valeur. Certaines options prennent en charge un ensemble défini de valeurs. SnowSQL renvoie une erreur si la valeur fournie n’est pas prise en charge. Vous ne pouvez pas créer de nouvelles options.

Pour une liste de toutes les options de configuration que vous pouvez définir, utilisez la commande !options.

!source , !load

Exécute SQL à partir d’un fichier. Vous pouvez exécuter SQL à partir de fichiers locaux ou d’une URL.

Par exemple :

user#> !source example.sql

user#> !load /tmp/scripts/example.sql

user#> !load http://www.example.com/sql_text.sql

!spool

Cette commande peut être exécutée de deux façons :

  • Activez le spooling et écrivez les résultats de toutes les instructions/requêtes suivantes dans le fichier spécifié :

    !spool <nom_fichier>

  • Désactivez le spooling des résultats (s’il est activé) :

    !spool off

Par exemple :

user#> select 1 num;

+-----+
| NUM |
|-----|
|   1 |
+-----+

user#> !spool /tmp/spool_example

user#> select 2 num;

+---+
| 2 |
|---|
| 2 |
+---+

user#> !spool off

user#> select 3 num;

+---+
| 3 |
|---|
| 3 |
+---+

user#> !exit

Goodbye!

$ cat /tmp/spool_example

+---+
| 2 |
|---|
| 2 |
+---+

Vous pouvez modifier le format de sortie en exécutant d’abord la commande !set output_format=<format>. Cette option prend en charge les valeurs suivantes :

  • custom

  • expanded

  • fancy_grid

  • grid

  • html

  • latex

  • latex_booktabs

  • mediawiki

  • orgtbl

  • pipe

  • plain

  • psql

  • rst

  • simple

  • tsv

Valeur recommandée : psql, fancy_grid ou grid

Par exemple, pour une sortie au format CSV :

user#> !set output_format=csv

user#> !spool /tmp/spool_example

!system

Exécute une commande shell.

!system <commande>

L’exemple suivant exécute la commande ls dans le répertoire personnel de l’utilisateur :

user#> !system ls ~

!variables , !vars

Répertorie toutes les variables actuelles. Renvoie chaque paire <nom_variable>=<valeur_variable> actuellement définie.

Une fois qu’une variable est assignée, elle ne peut pas être supprimée, mais sa valeur peut être supprimée en attribuant aucune valeur au nom de la variable. Par exemple :

user#> !set variable_substitution=true

user#> !define SnowAlpha=_ALPHA_

user#> !variables

+------------------+---------+
| Name             | Value   |
|------------------+---------|
| snowalpha        | _ALPHA_ |
+------------------+---------+

user#> !define SnowAlpha

user#> !variables

+------------------+-------+
| Name             | Value |
|------------------+-------|
| snowalpha        |       |
+------------------+-------+

user#> !define snowalpha=456

user#> select &snowalpha;

+-----+
| 456 |
|-----|
| 456 |
+-----+

Pour plus d’informations sur le paramétrage des variables, voir Utilisation de variables (dans ce chapitre).

Dépannage

Message d’erreur : Variable is not defined

Cause

Dans certains cas, cela peut être causé par l’utilisation d’une esperluette (caractère de substitution variable) dans une commande CREATE FUNCTION.

create function mask_bits(...)
    ...
    as
    $$
    var masked = (x & y);
    ...
    $$;
Solution

Aucune solution à ce problème ne fonctionnera dans toutes les situations. Toutefois, si vous n’avez pas l’intention d’utiliser la substitution de variable, vous pouvez éviter le problème en la désactivant. Pour désactiver la substitution de variable, exécutez la commande suivante :

!set variable_substitution=false;

Pour plus d’informations sur la substitution de variables, voir Utilisation de variables.