Une nouveauté majeure du client psql de PostgreSQL 10 est le support des branchements conditionnels, exprimables via ces nouvelles méta-commandes:

\if EXPR1
  ...
\elif EXPR2
  ... 
\else
  ...
\endif

Voyons déjà quelles sont les différences entre cette approche et les instructions IF / ELSIF / ELSE / END IF du langage plpgsql, déjà disponibles dans les fonctions et les blocs anonymes DO, avec ce type de syntaxe:

 DO $$
   BEGIN
     IF expression-sql THEN
      -- instructions
     ELSIF autre-expression-sql
       -- instructions
     END IF;
   END
 $$ language plpgsql;

COMMIT et ROLLBACK conditionnel

Il se trouve que COMMIT ou ROLLBACK ne peuvent pas être initiés de l'intérieur d'un bloc DO, ce bloc étant confiné à la transaction dont il dépend. C'est le même modèle d'exécution que pour les fonctions, qui sont soumises à la même contrainte On peut y insérer des sous-transactions via SAVEPOINT, mais la transaction principale n'est réellement contrôlable que par le client SQL.

Justement les branches psql offrent une solution simple à ce problème, puisqu'un script peut maintenant comporter une séquence du type:

 BEGIN;
 -- écritures en base
 \if :mode_test
   \echo 'Mode test: Annulation transactionnelle des modifications'
   ROLLBACK;
 \else
   \echo 'Validation transactionnelle des modifications'
   COMMIT;
 \endif

La variable psql mode_test peut être initialisée de l'extérieur, comme une option, via un appel en shell de la forme: $ psql -v mode_test=1 -U user -d database, ce qui donne un équivalent du "–dry-run" qu'ont certaines commandes comme make.

Syntaxe des expressions

L'interpréteur psql n'est pas doté d'un évaluateur interne (pas encore?), et la condition derrière un \if doit être une chaîne de caractères interprétable en booléen, c'est-à-dire true et false ou leurs diminutifs t et f, ou 0 et 1, ou encore on et off.

Quand le script n'a pas la valeur à tester directement sous cette forme, il faut la produire, soit par une commande externe via l'opérateur backtick (guillemet oblique comme dans \set var `commande`), soit par une requête SQL.

Prenons à titre d'exemple le cas où il faut comparer deux numéros sémantiques de version au format MAJOR.MINOR.PATCHLEVEL (1, 2 ou 3 nombres), l'un correspondant à une version d'un ensemble d'objets déployés en base, l'autre à un niveau de mise à jour à faire via notre script.

Appeler le shell pour tester une condition

Un avantage d'utiliser une évaluation externe est qu'elle fonctionnera indépendamment de l'état de la session SQL (notamment non connectée ou dans une transaction en échec). Par ailleurs, il peut y avoir des situations où un programme externe est plus adapté. Dans l'exemple de la comparaison de version, les systèmes basés sur Debian ont la commande dpkg --compare-versions qui fait plutôt bien l'affaire, sinon cette entrée de stackoverflow propose diverses solutions.

Cependant l'opérateur backtick appelant une commande externe présente deux subtilités qui compliquent un peu la tâche avec \if:

  • il ne lit pas le statut de la commande mais ce qu'elle affiche sur sa sortie standard, alors que la plupart des commandes de test (à commencer par la commande test justement) n'affichent rien.
  • le standard en test shell est 0 pour positif et 1 pour négatif dans le statut, alors qu'on veut les valeurs inverses dans psql.

Sachant ça et en supposant bash comme shell, ça veut dire qu'on devra écrire:

\if `! dpkg --compare-versions ":version_db" ge ":version_script"; echo $?`

(si vous trouvez plus simple, n'hésitez pas à le dire en commentaire!)

A noter au passage que l'interpolation des variables psql par l'opérateur backtick est également une nouveauté de la version 10, c'est-à-dire qu'avec une version antérieure, les :version_db et :version_script auraient été présents tels quels dans la commande.

Et que se passe-t-il en cas d'erreur de la commande shell? Généralement, le résultat dans $? n'étant ni 1 ni 0 mais plutôt 2 et plus, le \if rejette cette valeur qui n'est pas assimilable à un booléen, émet un message d'erreur et poursuit l'exécution en supposant arbitrairement faux comme résultat de la comparaison.

Utiliser l'interpréteur SQL pour tester une condition

Bien sûr, on peut aussi produire la valeur de notre comparaison par une requête. La portabilité du SQL sera aussi préférable à des commandes shell si par exemple le script doit être déployé sous Windows. Même si bash et plein de commandes shell existent sous Windows (cf MSYS ou MSYS2) et que c'est plutôt une bonne idée de les installer, on ne peut pas trop espérer qu'elles le soient par défaut.

Pour la méthode SQL, cette entrée de dba.stackexchange: How to ORDER BY typical software release versions like X.Y.Z inspire une solution à base de tableaux d'entiers.

Le résultat booléen de la comparaison est transféré dans une variable via la méta-commande \gset en fin de requête:

SELECT (string_to_array(:version_db, '.')::int[] >=
        string_to_array(:version_script, '.')::int[]) AS a_jour \gset
\if :a_jour
   \echo 'Le schéma est déjà en version' :version_db
   \quit
\endif

Contrairement au cas de la commande shell, psql n'offre pas pour le moment de syntaxe pour mettre une requête SQL derrière un \if. Il faut nécessairement passer par une variable booléenne intermédiaire. Une consolation: on peut charger plusieurs variables en une seule requête puisque \gset apparie chaque colonne du résultat à une variable de même nom.

En cas d'erreur de la requête, ou si elle ne produit aucune ligne, et s'il y avait déjà une valeur dans les variables en question, elles restent inchangées. Il faudra se méfier dans les scripts qu'un \if ne teste pas la valeur précédente d'une variable dans le cas où une requête censée l'affecter a la moindre chance d'échouer. Au pire, on devra réinitialiser ces variables avant chaque requête, avec une séquence du style:

\unset var1
\unset var2
SELECT ... AS var1, ... AS var2 FROM tables... \gset
\if :var1   -- erreur et \if faux si problème avec la requête ci-dessus 
  ...
\elif :var2  -- erreur et \elif faux si problème avec la requête ci-dessus 
  ...
\else
  ...      -- mais cette branche sera exécutée si erreur de requête
\endif

Ca peut être l'occasion de rappeler qu'il est bon de mettre

\set ON_ERROR_STOP on

dans les scripts sensibles. Cette option est un peu l'équivalent du set -e du shell, elle provoque la sortie immédiate du script en cours en cas d'erreur.