Contexte

Dans le cadre de mon travail, je devais avoir des jobs Talend (version 8, Java 11) qui devaient se connecter à une base de données SQL Server (version 2019). Jusqu’ici, aucune difficulté majeure. Une connexion classique TCP/IP avec login/mot de passe SQL.

Mais un jour, la DSI de cette entreprise changea quelques protocoles, notamment la connexion à la base de données, qui devaient dorénavant s’effectuer via l’authentification Windows uniquement. J’avais déjà vu que cela était possible avec Talend mais je ne l’avais pas encore testé en condition réelle.

Solution

La solution passe par plusieurs actions. Mais sur le net, difficile d’avoir une information claire et fonctionnelle. Au bout de plusieurs recherches et essais, j’ai fini par avoir une solution opérationnelle.

Première action : récupérer les drivers JDBC sur le site de Microsoft

Le drivers JDBC, sous la forme d’un fichier ZIP est proposé à cette adresse par Microsoft : https://learn.microsoft.com/en-us/sql/connect/jdbc/download-microsoft-jdbc-driver-for-sql-server?view=sql-server-ver15

Cette archive servira à deux choses :

• avoir une DLL nécessaire pour l’authentification,
• avoir le fichier JAR qui sera utilisé par Talend pour se connecter à la DB (plus à jour que Talend/Java 11)

Une fois téléchargée, décompressez-la, peut importe l’endroit.

Deuxième action : déterminer la version Java (x86 ou x64)

Dans PowerShell, identifiez la version de Java (x86 ou x64) via :

java -version

Attention ! ce n’est pas parce que vous êtes sur un Windows 64 bit que la version java installée est 64 bit ! Vérifiez avant !

En fonction de cela, dans le dossier auth de l’archive, sélectionnez la bonne DLL en allant dans le bon sous-répertoire en fonction de votre version java (x86 ou x64) vue juste avant.

Troisième action : mise en place de la DLL

C’est là qu’on a des informations contradictoires sur le net à ce sujet.

En étant administrateur Windows, copiez cette DLL dans le répertoire bin de votre installation Java (et non pas dans System32 de Windows comme on peut le trouver dans certaines solutions).

Dans mon cas, j’ai fait ainsi :

cp C:\Users\Michel\Downloads\sqljdbc_12.2.0.0_fra\sqljdbc_12.2\fra\auth\x64\mssql-jdbc_auth-12.2.0.x64.dll C:\Program Files\Java\jdk-11.0.15.1\bin\

Adaptez cela en fonction de votre environnement et de l’archive téléchargée. Ayant pris une archive avec le traduction en français, j’ai un dossier fra, mais pour d’autres langues vous aurez par exemple enu pour Universal English ou encore d’autres possibilités. Ne copiez pas à l’aveugle ma commande !

Quatrième action : utiliser le JAR dans Talend

Si vous ne passez pas par cette étape, vous aurez probablement des erreurs Java lors de la compilation de vos jobs.

Affichez dans Talend l’onglet listant les modules (via Fenête > Montrer la vue).

Dans la liste des modules Talend, tapez mssql-jdbc.jar dans la zone de recherche afin de rechercher les éléments concernés par ce JAR.

Ensuite, dans la liste des modules, sélectionnez-en un au hasard, cliquez sur le bouton de modification (en bout de ligne). Dans la fenêtre apparaissant, modifiez le champ URI maven personnalisé par l’URL de MSSQL JDBC que vous trouverez sur Maven. Ici, c’est https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc/12.2.0.jre11. Talend modifie l’URL automatiquement afin d’avoir une URI Maven compatible. Validez.

Si vous devez revenir en arrière, il suffit de refaire les manipulations pour revenir à la popup et vous décocher la case URI MVN personnalisée.

Cinquième action : utiliser le bon driver

Ensuite, dans Talend, pour une connexion DB devant utiliser l’identification intégrée de Windows, il faut sélectionner le fournisseur JDBC Microsoft et non plus JTDS Open source, puis il faut laisser les champs login/mot de passe vides, mais vous devrez spécifier la chaîne de caractères suivante dans Paramètres supplémentaires JDBC :

"integratedSecurity=true;trustServerCertificate=true"

Un test de votre connexion devrait fonctionner et s’achever sans erreur.

Conclusion

Si vous avez été dans mon cas, à tenter de rendre fonctionnelle une connection vers SQL Server 2019 à l’aide de Talend 8 avec Java 11, et que cela été infructueux, alors j’espère que mon article vous aura servi dans votre cas.

Pourquoi passer par Docker

Oracle Express Edition (ou xe de son petit nom) est disponible gratuitement, mais son installation simple, sous linux, nécessite d’être sur une distribution compatible RedHat comme CentOS ou sans surprise Oracle Linux (OL), la distribution proposée par Oracle. Si vous êtes sous une autre distribution, l’installation devient compliquée. Ce n’est vraiment pas très fair-play de lapart d’Oracle, quand on compare avec Microsoft SQL Server Developer qui peut s’installer très facilement surdifférentes distributions Linux.

Bref.

Si comme moi, vous utilisez une distribution Ubuntu, par chance, une image Docker très pratique permet l’utilisation d’Oracle XE dans un conteneur, et en plus, la prise en main est aisée.

Installation

Pour ce qui suit, je me base sur une Ubuntu 20.04 LTS et sur Oracle Database XE 21c.

Je passe les détails sur l’installation de Docker sur votre système, un article de Digital Ocean l’explique très bien.

L’image Docker qui nous intéresse ici est celle de gvenzl/oracle-xe, disponible sur Docker Hub.

Récupérez cette image ainsi :

docker pull gvenzl/oracle-xe

Vous aurez alors la dernière version disponible. Au moment d’écrire ces lignes, il s’agissait d’Oracle Database 21c. Si vous souhaitez installer une autre version, utilisez le système des tags de Docker. Par exemple, pour avoir la version 11g2, faites ainsi :

docker pull gvenzl/oracle-xe:11.2.0.2

Lancement

Maintenant que nous avons l’image, préparons un peu le terrain pour avoir une persistance des données : ce serait bien de pouvoir les conserver d’une foissur l’autre non ?

Qui dit persistance, dit volume : pour cela, créons un volume Docker et appelons-le volora en tapant la commande suivante :

docker volume create volora

Vous avez maintenant un volume pour garder vos modifications en base de données.

Définissons maintenant un mot de passe pour les utilisateurs SYS et SYSTEM ainsi que pour un utilisateur normal, arbitrairement dénommé TEST :

• Pour SYS et SYSTEM, pour l’exemple, choisissons oracle comme mot de passe.
• Pour l’utilisateur normal, son nom sera TEST et son mot de passe sera elcaro.

Il va de soi qu’il vous faudra choisir des mots de passe plus robustes.

Nous avons l’image, les mots de passe, le volume, il n’y a plus qu’à mettre tout ça ensemble ! Lançons Docker ainsi, en nommant notre container oracle_xe :

docker run -d -p 1521:1521 \    --name=oracle_xe \    -e ORACLE_PASSWORD=oracle \    -e APP_USER=TEST \    -e APP_USER_PASSWORD=elcaro \    -v volora:/opt/oracle/oradata \    gvenzl/oracle-xe

Si vous avez un problème de droit, utilisez sudo devant la commande.

Notez bien le chemin associé au volume : il correspond à celui des versions d’Oracle postérieure à 11g2. Si vous avez spécifié un tag pour installer l’image Docker pour Oracle XE 11g2, alors la commande sera la suivante :

docker run -d -p 1521:1521 \    --name=oracle_xe \    -e ORACLE_PASSWORD=oracle \    -e APP_USER=TEST \    -e APP_USER_PASSWORD=elcaro \    -v volora:/u01/app/oracle/oradata \    gvenzl/oracle-xe

Le chemin change de /opt/oracle/oradata à /u01/app/oracle/oradata.

Par défaut, le service name est défini à XEPDB1.

Utilisation

Testons maintenant la connexion à la base avec SQLcl et avec DBeaver.

SQLcl

Testons la connexion avec l’utilisateur TEST :

sqlcl TEST/elcaro@localhost:1521/XEPDB1

On se connecte bien comme le montre la capture suivante :

Testons la création d’une table :

CREATE TABLE THING (NAME VARCHAR2 ( 100 ) NOT NULL,CREATED_AT DATE DEFAULT SYSDATE NOT NULL  );

Et insérons-y une donnée :

INSERT INTO THING (NAME) VALUES ('Foo');

Tout se déroule bien comme le montre la capture suivante :

Une sélection de la table le confirme :

Bien.

Maintenant, arrêtons notre conteneur Docker, et relançons-le, pour vérifier la persistance des données :

docker stop oracle_xedocker start oracle_xe

En se reconnectant et en effectuant le SELECT à nouveau, on a bien la table qui est toujours présente et avec du contenu :

Il reste un petit test à faire : quid de l’utilisateur SYSTEM ? Peut-il bien se connecter ? Réponse :

Verdict : tout fonctionne.

DBeaver

Pour ajouter la connexion à DBeaver, assurer vous d’avoir les données au bon endroit, comme sur la capture suivante :

Une fois la connexion créée, vous aurez remarqué que ce qui a été fait avant est bel et bien présent.

Conclusion

Si vous n’êtes pas sur une distribution linux RHEL like, alors l’utilisation d’un conteneur Docker est une franche bonne idée pour travailler avec Oracle Database XE. Facile et rapide, c’est l’idéal.

Premier piège : les SELECT sans FROM en erreur

Vous commencez votre premier jour d’utilisation sur Oracle. vous souhaitez juste lancer un test basique, comme par exemple faire un calcul ou tester une fonctionde chaîne.

Vous faites alors :

SELECT 2 + 3;

Ou encore :

SELECT UPPER('coucou');

Et à chaque fois, pour ces requêtes très simples, vous obtenez une erreur :

ORA-00923: mot-clé FROM absent à l'emplacement prévu

Notez bien le début du message d’erreur : ils commencent tous ainsi, avec ORAsuivi d’un numéro à 5 chiffres pour le code d’erreur.

Le message nous dit que le mot-clé FROM est manquant, pourtant, les requêtesque vous faites semblent correctes.

Cela va vous surprendre, mais sous Oracle, il faut toujours utiliser le mot-cléSELECT avec le mot-clé FROM, sinon, vous obtenez l’erreur mentionnée ci-dessus.

Mais alors, comment faire pour ce genre de requête ? La réponse estl’utilisation d’une table fictive appelée dual. Dès que vous avez des requêtes ne faisant pas intervenir de table, de vue ou de CTE, alors ajoutezsystématiquement FROM dual à votre requête.

Nous pouvons donc réécrire les requêtes précédentes ainsi :

SELECT 2 + 3 FROM dual;

Elle donne bien le bon résultat et sans erreur :

2+3|---+  5|

Et maintenant avec :

SELECT UPPER('coucou') FROM dual;

Elle fonctionne également :

UPPER('COUCOU')|---------------+COUCOU         |

Voyons maintenant un autre cas : une CTE récursive.

WITH cte_exemple(n) AS (SELECT 0UNION ALLSELECT n + 1 FROM cte_exemple WHERE  n < 9)SELECT * FROM cte_exemple;

Vous obtiendrez encore l’erreur du mot-clé FROM manquant.

Donc pour lancer une CTE récursive, il faut penser à spécifier le FROM dual !

En voici la version corrigée :

WITH cte_exemple(n) AS (SELECT 0 FROM dualUNION ALLSELECT n + 1 FROM cte_exemple WHERE  n < 9)SELECT * FROM cte_exemple;

Et cela donne le résultat escompté :

N|-+0|1|2|3|4|5|6|7|8|9|

Donc retenez bien : pas de SELECT sans FROM !

Deuxième piège : CREATE TABLE DEFAULT en erreur

Vous voulez créer une table assez simple, avec certaines colonnes devant avoirune valeur par défaut, et ne devant pas valoir NULL.

Cela pourrait être l’exemple suivant :

CREATE TABLE THING (NAME VARCHAR2 ( 100 ) NOT NULL,CREATED_AT DATE NOT NULL DEFAULT SYSDATE  );

Vous exécutez la requête de création de table, sûr⋅e de vous, et là vous obtenezl’étrange erreur suivante :

ORA-00907: parenthèse de droite absente

Pourtant, il ne manque pas de parenthèse. Alors, pourquoi cette erreur est-ellelevée ?

L’explication est qu’Oracle est peu tolérant au changement d’ordre dans les déclarations. Pourune syntaxe qui serait valable avec un autre SGBD, on obtient une erreur avec Oracle, mais une erreur pas claire car comme il s’attend à un ordre différent des éléments, il soulève une erreur par rapport à quelque chose qu’il attend et qui n’a pas lieu d’être ici. Pour faire simple, il soulève une erreur innapropriée.

La solution est de faire attention à l’emplacement de la clause DEFAULT. Il faut ici la placer après le nom de la colonne, comme ceci par exemple :

CREATE TABLE THING (NAME VARCHAR2 ( 100 ) NOT NULL,CREATED_AT DATE DEFAULT SYSDATE NOT NULL  );

La requête s’exécute sans erreur, la table est bien créée.

Insérons-y une ligne :

INSERT INTO THING (NAME) VALUES ('Foo');

Voyons si la valeur par défaut a bien été prise :

SELECT * FROM THING;

La sélection donne :

NAME|CREATED_AT             |----+-----------------------+Foo |2022-04-23 11:41:19.000|

Nous avons bien la valeur par défaut pour la date de création.

Donc retenez bien : attention à l’ordre de déclaration qui est assez rigide chez Oracle, contrairement à d’autres SGBD.

Troisième piège : les clés primaires auto-incrémentées

Oracle ne propose pas une, pas deux, mais trois façons différentes de déclarerune clé primaire auto-incrémentée. Selon ce que vous aurez choisi, vousobtiendrez ou non des erreurs lors des insertions de données.

Voyons cela avec 3 exemples.

Auto-incrémentation basique

Testons directement avec cette déclaration :

CREATE TABLE BAR (ID NUMBER GENERATED AS IDENTITY PRIMARY KEY,NAME VARCHAR2 ( 100 ) NOT NULL  );

La table est bien créée. insérons maintenant des données :

INSERT INTO BAR (NAME) VALUES ('Foo');

Fonctionne et donne ceci :

ID|NAME|--+----+ 1|Foo |

Insérons en spécifiant une valeur pour la clé primaire :

INSERT INTO BAR (ID, NAME) VALUES (2, 'Thing');

Oracle lève l’erreur suivante :

ORA-32795:  impossible d'insérer la valeur dans une colonne d'identité avec            les mots-clés GENERATED ALWAYS

Voyons avec la valeur NULL pour la clé :

INSERT INTO BAR (ID, NAME) VALUES (NULL, 'Bar');

Oracle lève la même erreur :

ORA-32795:  impossible d'insérer la valeur dans une colonne d'identité avec            les mots-clés GENERATED ALWAYS

Donc, pour un GENERATED AS IDENTITY il ne faut pas spécifier de valeur pour lechamp de la clé primaire lors des insertions, Oracle se charge de tout.

Auto-incrémentation par défaut

Passons à la deuxième façon de délarer une clé primaire avec auto-incrémentation.

CREATE TABLE BAR2 (ID NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,NAME VARCHAR2 ( 100 ) NOT NULL  );

La table est créée, réalisons maintenant différentes insertions :

INSERT INTO BAR2 (NAME) VALUES ('Foo');

Cette première insertion sans spécifier de valeur pour la colonneauto-incrémenté passe sans problème.

INSERT INTO BAR2 (ID, NAME) VALUES (2, 'Thing');

La deuxième insertion, en donnant une valeur pour la colonne auto-incrémentée,passe également sans difficulté.

INSERT INTO BAR2 (ID, NAME) VALUES (NULL, 'Bar');

Cette troisième insertion, en passant NULL pour la colonne auto-incrémentée,lève l’erreur suivante :

ERREUR : ORA-01400: impossible d'insérer NULL dans ("TEST"."BAR2"."ID")

Nous avons donc au final pour cette table :

ID|NAME |--+-----+ 1|Foo  | 2|Thing|

Donc, pour un GENERATED BY DEFAULT AS IDENTITY il ne faut pas passer la valeurNULL pour le champ de la clé primaire lors des insertions.

Auto-incrémentation par défaut pour NULL

Voyons maintenant ce qu’il en est avec la troisième façon de définir un champauto-incrémenté comme clé primaire.

CREATE TABLE BAR3 (ID NUMBER GENERATED BY DEFAULT ON NULL AS IDENTITY PRIMARY KEY,NAME VARCHAR2 ( 100 ) NOT NULL  );

La table étant créée, testons les différentes façons d’insérer les données :

INSERT INTO BAR3 (NAME) VALUES ('Foo');

Cette première insertion sans spécifier de valeur pour la colonneauto-incrémentée passe sans problème.

INSERT INTO BAR3 (ID, NAME) VALUES (2, 'Thing');

La deuxième insertion, en donnant une valeur pour la colonne auto-incrémentée,passe également sans difficulté.

INSERT INTO BAR3 (ID, NAME) VALUES (NULL, 'Bar');

La troisième insertion, en forçant à NULL pour la colonne auto-incrémentée,passe cette fois-ci sans difficulté.

Voyons maintenant les valeurs insérées :

SELECT * FROM BAR3;

Nous avons bien un ID à 3 pour l’insertion avec NULL :

ID|NAME |--+-----+ 1|Foo  | 2|Thing| 3|Bar  |

Donc, pour un GENERATED BY DEFAULT ON NULL AS IDENTITY, il est possibled’utiliser tous les types d’insertion possible !

PK AI récapitulatif

Voici un tableau récapitulant les insertions possibles en fonction du type d’auto-incrémentation utilisé.

Conclusion

J’espère vous avoir fait épargner du temps en recherche de résolution de problèmepour ces quelques particularités d’Oracle qui peuvent surprendre de prime abord.

L’extension Calendar de PHP est très pratique, mais la majeure partie de ses fonctionnalités est très peu utilisée dans l’ensemble.

Chez nous, en France et dans les pays francophones, les fonctions fréquemment utilisées de cette extension sont easter_date() et cal_days_in_month().

Comment faire pour avoir un équivalent si vous ne pouvez pas utiliser l’extension Calendar ? C’est ce que je vais vous montrer.

Exemple connu : Pâques

La fonction easter_date() permet d’avoir la date de Pâques pour une année donnée.

Cela est très pratique, car outre Pâques, cela permet d’avoir par déduction lesdates d’autres fêtes comme l’Ascension ou la Pentecôte. Pouvoir déterminer la date de Pâques permet de déterminer tous les jours fériés ayant un date variable en France.

J’ai fait un article dernièrement avec MySQL à ce sujet. Maintenant, transposons le code en PHP. Le but est de créer une fonction prenantun paramètre int pour l’année dont on veut déterminer la date de Pâques, et quisort un object DateTime pour manipuler la date comme on le désire.

// https://de.wikipedia.org/wiki/Gau%C3%9Fsche_Osterformel#Eine_erg.C3.A4nzte_Osterformelfunction easter(int $year): \DateTime{    $k = intdiv($year, 100);    $m = 15 + intdiv((3 * $k + 3), 4) - intdiv((8 * $k + 13), 25);    $s = 2 - intdiv((3 * $k + 3), 4);    $a = $year % 19;    $d = (19 * $a + $m) % 30;    $r = intdiv(($d + intdiv($a, 11)), 29);    $og = 21 + $d - $r ;    $sz = 7 - ($year + intdiv($year, 4) + $s) % 7;    $oe = 7 - ($og - $sz) % 7;    $os = $og + $oe;    $result = new \DateTime(sprintf('%04s-03-01', $year));    $result->add(        \DateInterval::createFromDateString(            sprintf('%s days', $os-1)        )    );        return $result; }

Il y a d’autres implémentations avec d’autres algorithmes que vous trouverezfacilement sur le net.

Jouons un peu avec notre fonction :

var_dump(easter(2022)->format('d/m/Y'));// string(10) "17/04/2022"var_dump(easter(2032)->format('d/m/Y'));// string(10) "28/03/2032"var_dump(easter(2042)->format('d/m/Y'));// string(10) "06/04/2042"var_dump(easter(1789)->format('d/m/Y'));//string(10) "12/04/1789"

Voilà notre première fonction de remplacement opérationnelle ! Vous pouvez comparer à la liste des dates de Pâques.

Nombre de jours dans un mois donné

La fonction cal_days_in_month() de l’extension Calendar permet de récupérerle nombre de jours dans un mois d’une année donnée. Il est possible despécifier un type de calendrier particulier en prime.

Si vous ne disposez pas de l’extension Calendar, alors sachez que l’utilisationdes fonctionnalités des dates en natif suffisent.

Sur un objet DateTime, l’appel à la méthode format() avec l’argument 't'permet de retourner le nombre de jours dans le mois de la date pré-définie.

Par exemple, pour février 2022, on peut faire ceci :

var_dump((new DateTime('2022-02'))->format('t'));// string(2) "28"

L’utilisation n’est pas très pratique, nous allons donc créer une fonction quiprend obligatoirement le mois, et en option, l’année. Si l’année n’est pasfournie, alors c’est l’année en cours qui est prise.

Et tant qu’à faire, on va retourner une valeur entière int, et non une chaîne decaractères string.

function daysInMonth(int $month, int $year = null): int{    $date = sprintf(        '%s-%02s-01',         is_null($year) ? (new \DateTime())->format('Y') : $year,        $month    );    return (int) (new DateTime($date))->format('t');}

Jouons un peu avec cette fonction :

var_dump(daysInMonth(2));// int(28)var_dump(daysInMonth(2, 2022));// int(28)var_dump(daysInMonth(2, 2020));// int(29)

C’est pas mal, maintenant protégeons-là un peu pour éviter d’entrer des valeursimpossibles comme un mois 13 ou une année hors de l’intervalle -9999/9999 :

function daysInMonth(int $month, int $year = null): int{    if ($month > 12 || $month < 1) {        throw new \InvalidArgumentException('Month must be in range 1;12');    }    if (!is_null($year) && ($year > 9999 || $year < -9999)) {        throw new \InvalidArgumentException('Year must be in range -9999;9999');    }    $date = sprintf(        '%s-%02s-01',         is_null($year) ? (new \DateTime())->format('Y') : $year,        $month    );    return (int) (new DateTime($date))->format('t');}

Voyons cela :

var_dump(daysInMonth(2));// int(28)var_dump(daysInMonth(2, 2022));// int(28)var_dump(daysInMonth(2, 9999));// int(28)var_dump(daysInMonth(2, 19999));// PHP Warning:  Uncaught InvalidArgumentException: Year must be in range -9999;9999 in php shell code:8// Stack trace:// #0 php shell code(1): daysInMonth()// #1 {main}//   thrown in php shell code on line 8var_dump(daysInMonth(2, -9999));// int(28)var_dump(daysInMonth(2, -19999));// PHP Warning:  Uncaught InvalidArgumentException: Year must be in range -9999;9999 in php shell code:8// Stack trace:// #0 php shell code(1): daysInMonth()// #1 {main}//   thrown in php shell code on line 8var_dump(daysInMonth(2, 2099));// int(28)var_dump(daysInMonth(12, 2099));// int(31)var_dump(daysInMonth(13, 2099));// PHP Warning:  Uncaught InvalidArgumentException: Month must be in range 1;12 in php shell code:4// Stack trace:// #0 php shell code(1): daysInMonth()// #1 {main}//   thrown in php shell code on line 4var_dump(daysInMonth(-1, 2099));// PHP Warning:  Uncaught InvalidArgumentException: Month must be in range 1;12 in php shell code:4// Stack trace:// #0 php shell code(1): daysInMonth()// #1 {main}//   thrown in php shell code on line 4var_dump(daysInMonth(1, 2099));// int(31)var_dump(daysInMonth(0, 2099));// PHP Warning:  Uncaught InvalidArgumentException: Month must be in range 1;12 in php shell code:4// Stack trace:// #0 php shell code(1): daysInMonth()// #1 {main}//   thrown in php shell code on line 4

Pas mal non ? Libre à vous de l’intégrer dans une méthode de classe par exemple.

Conclusion

J’espère que ces deux fonctions pourront vous être utile si vous vous retrouvezsans le module Calendar de PHP.

Prérequis

Tout ce qui suit a été réalisé sous MySQL 8.

Une petite recherche

Une recherche repide sur le Net permet d’identifier deux fonctions candidates intéressantespour le calcul de la date de Pâques en Occident (désolés les Orthodoxes, je penserai à vous possiblement dans un futur article) sous MySQL.

La première, sous licence BSD, par Jan Weiher dans le dépôt Github https://github.com/jweiher/mysql-easter.

La voici, avec un petit ajout de ma part, car il faut préciser si la fonction est déterministe ou non, vu que son code est ancien, il ne contenait pas ce mot-clé :

delimiter $$CREATE FUNCTION `easter_f`(X INTEGER) RETURNS date deterministicBEGINDECLARE K,M,S,A,D,R,OG,SZ,OE,OS INT;DECLARE EASTERDATE DATE;SET K = X DIV 100;SET M = 15 + (3*K + 3) DIV 4 - (8*K + 13) DIV 25;SET S = 2 - (3*K + 3) DIV 4;SET A = X MOD 19;SET D = (19*A + M) MOD 30;SET R = (D + A DIV 11) DIV 29;SET OG = 21 + D - R ;SET SZ = 7 - (X + X DIV 4 + S) MOD 7;SET OE = 7 - (OG - SZ) MOD 7;SET OS = OG + OE;SET EASTERDATE = date_add(concat(X, '-03-01'), INTERVAL OS-1 DAY);RETURN EASTERDATE;END$$delimiter ;

La fonction se crée bien sous MySQL 8 et s’exécute bien.

La seconde est celle de Scott Noyes sur Planet MySQL, dont j’ai changé le typage YEAR en INTEGER pour ne pas se limiter à l’intervalle d’années 1901 à 2155 :

DROP function easter;DELIMITER //CREATE FUNCTION easter(inYear INTEGER) RETURNS DATE DETERMINISTICBEGIN    DECLARE a, b, c, d, e, k, m, n, p, q INT;    DECLARE easter DATE;    SET k = FLOOR(inYear / 100);    SET a = MOD(inYear, 19);    SET b = MOD(inYear, 4);    SET c = MOD(inYear, 7);    SET q = FLOOR(k / 4);    SET p = FLOOR((13 + 8 * k) / 25);    SET m = MOD((15-p+k-q), 30);    SET d = MOD((19 * a + m), 30);    SET n = MOD((4+k-q), 7);    SET e = MOD((2*b+4*c+6*d+n), 7);    SET easter = CASE        WHEN d + e <= 9 THEN CONCAT_WS('-', inYear, '03', 22 + d + e)        WHEN d = 29 AND e = 6 THEN CONCAT_WS('-', inYear, '04-19')        WHEN d = 28 AND e = 6 AND a > 10 THEN CONCAT_WS('-', inYear, '04-18')        ELSE CONCAT_WS('-', inYear, '04', LPAD(d + e - 9, 2, 0))    END;    RETURN easter;END//DELIMITER ;

Elle aussi s’installe et s’exécute correctement sur MySQL 8.

Voyons maintenant s’il y a des différences (bugs donc) entre les deux en les testant à partir de l’année 1200 et pour les 1000 ans suivant :

with recursive cte_years as (  select 1200 y, 1 inc   union all  select y + 1 y, inc + 1 inc from cte_years where inc < 1000),cte_compare as (  select easter_f(y) = easter(y) test from cte_years)select * from cte_compare where test = 0;

Ce qui donne :

Empty set (0,06 sec)

OK, même résultat. Voyons en terme de performance maintenant :

with recursive cte_years as (  select 1200 y, 1 inc   union all  select y + 1 y, inc + 1 inc from cte_years where inc < 1000),cte_compare as (  select easter_f(y) from cte_years)select * from cte_compare;

La première fonction donne un temps d’exécution de 0,03 ms.

with recursive cte_years as (  select 1200 y, 1 inc   union all  select y + 1 y, inc + 1 inc from cte_years where inc < 1000),cte_compare as (  select easter(y) from cte_years)select * from cte_compare;

La deuxième met 0,04 ms. Petite différence, mais cela peut jouer pour des appels fréquents.Je vais utiliser la première.

Exploitons ça !

Maintenant que nous avons une fonction toute prête pour nous retourner la datede Pâques pour une année donnée, on peut déterminer les dates d’autres jours fériés qui dépendent de Pâques :

• le lundi de Pâques, 1 jour après Pâques,
• l’Ascension, 39 jours après Pâques,
• et la Pentecôte, 49 jours après Pâques.

Pour les autres, ce sont des dates fixes :

• Jour de l’an, le permier janvier,
• Fête des Travailleurs, le premier mai,
• Victoire des Alliés, le 8 mai
• Fête Nationale, le 14 juillet,
• Assomption, le 15 août,
• Toussaint, le permier novembre
• Armistice, le 11 novembre
• et enfin Noël, le 25 décembre.

Notre fonction devra prendre une date en entrée, et en sortie donner le nom dujour férié (en STRING) ou NULL si le jour ne correspond pas à un jour férié.

Un exemple d’implémentation pourrait être le suivant :

DELIMITER //CREATE FUNCTION `is_fr_public_holiday`(someday DATE) RETURNS varchar(25)    DETERMINISTICBEGIN    -- oui c’est franco-français, alors les variables sont en français :)DECLARE annee INTEGER;DECLARE mois INTEGER;DECLARE jour INTEGER;    DECLARE paques DATE;    DECLARE lundi_de_paques DATE;    DECLARE ascension DATE;    DECLARE pentecote DATE;        SET annee = YEAR(someday);SET mois = MONTH(someday);    SET jour = DAY(someday);    -- on commence par les cas simples    IF mois = 1 AND jour = 1 THEN         RETURN 'Jour de l’an';    END IF;    IF mois = 5 AND jour = 1 THEN         RETURN 'Fête des Travailleurs';    END IF;    IF mois = 5 AND jour = 8 THEN         RETURN 'Victoire des Alliés';    END IF;    IF mois = 7 AND jour = 14 THEN         RETURN 'Fête Nationale';    END IF;    IF mois = 8 AND jour = 15 THEN         RETURN 'Assomption';    END IF;    IF mois = 11 AND jour = 1 THEN         RETURN 'Toussaint';    END IF;    IF mois = 11 AND jour = 11 THEN         RETURN 'Armistice';    END IF;    IF mois = 12 AND jour = 25 THEN         RETURN 'Noël';    END IF;    SET paques = (SELECT easter_f(annee));    SET lundi_de_paques = (SELECT date_add(paques, INTERVAL +1 DAY));    SET ascension = (SELECT date_add(paques, INTERVAL +39 DAY));    SET pentecote = (SELECT date_add(paques, INTERVAL +49 DAY));    IF someday = paques THEN        RETURN 'Pâques';    END IF;    IF someday = lundi_de_paques THEN        RETURN 'Lundi de Pâques';    END IF;    IF someday = ascension THEN        RETURN 'Ascension';    END IF;    IF someday = pentecote THEN        RETURN 'Pentecôte';    END IF;RETURN NULL;END //DELIMITER ;

Testons avec la fête du moment :

SELECT is_fr_public_holiday('2022-04-17');

Qui donne :

+------------------------------------+| is_fr_public_holiday('2022-04-17') |+------------------------------------+| Pâques                             |+------------------------------------+1 row in set (0,01 sec)

Le lundi de Pâque :

SELECT is_fr_public_holiday('2022-04-18');

+------------------------------------+| is_fr_public_holiday('2022-04-18') |+------------------------------------+| Lundi de Pâques                    |+------------------------------------+1 row in set (0,00 sec)

Un jour quelconque :

SELECT is_fr_public_holiday('1978-01-14');

+------------------------------------+| is_fr_public_holiday('1978-01-14') |+------------------------------------+| NULL                               |+------------------------------------+1 row in set (0,00 sec)

Ça ne semble pas mal non ?

Du coup, pour toute l’année courante, nous pouvons faire la requête suivante pour avoir les jours fériés ou non :

with recursive cte_current_year as (    select  cast(concat(year(now()), '-01-01') as date) d    union all    select  cast(date_add(d, interval +1 day) as date) d    from    cte_current_year    where   d < concat(year(now()), '-12-31')),cte_name as (    select  d,             is_fr_public_holiday(d) holiday_name    from    cte_current_year)select  d,        holiday_name,        holiday_name is not null is_holidayfrom    cte_name;

Ce qui nous donne, en tronqué :

+------------+------------------------+------------+| d          | holiday_name           | is_holiday |+------------+------------------------+------------+| 2022-01-01 | Jour de l’an           |          1 || 2022-01-02 | NULL                   |          0 || 2022-01-03 | NULL                   |          0 |[...]| 2022-04-15 | NULL                   |          0 || 2022-04-16 | NULL                   |          0 || 2022-04-17 | Pâques                 |          1 || 2022-04-18 | Lundi de Pâques        |          1 || 2022-04-19 | NULL                   |          0 || 2022-04-20 | NULL                   |          0 |[...]| 2022-04-28 | NULL                   |          0 || 2022-04-29 | NULL                   |          0 || 2022-04-30 | NULL                   |          0 || 2022-05-01 | Fête des Travailleurs  |          1 || 2022-05-02 | NULL                   |          0 || 2022-05-03 | NULL                   |          0 || 2022-05-04 | NULL                   |          0 || 2022-05-05 | NULL                   |          0 || 2022-05-06 | NULL                   |          0 || 2022-05-07 | NULL                   |          0 || 2022-05-08 | Victoire des Alliés    |          1 || 2022-05-09 | NULL                   |          0 || 2022-05-10 | NULL                   |          0 |[...]| 2022-05-24 | NULL                   |          0 || 2022-05-25 | NULL                   |          0 || 2022-05-26 | Ascension              |          1 || 2022-05-27 | NULL                   |          0 || 2022-05-28 | NULL                   |          0 |[...]| 2022-06-03 | NULL                   |          0 || 2022-06-04 | NULL                   |          0 || 2022-06-05 | Pentecôte              |          1 || 2022-06-06 | NULL                   |          0 || 2022-06-07 | NULL                   |          0 |[...]| 2022-07-12 | NULL                   |          0 || 2022-07-13 | NULL                   |          0 || 2022-07-14 | Fête Nationale         |          1 || 2022-07-15 | NULL                   |          0 || 2022-07-16 | NULL                   |          0 |[...]| 2022-08-13 | NULL                   |          0 || 2022-08-14 | NULL                   |          0 || 2022-08-15 | Assomption             |          1 || 2022-08-16 | NULL                   |          0 || 2022-08-17 | NULL                   |          0 |[...]| 2022-10-30 | NULL                   |          0 || 2022-10-31 | NULL                   |          0 || 2022-11-01 | Toussaint              |          1 || 2022-11-02 | NULL                   |          0 || 2022-11-03 | NULL                   |          0 |[...]| 2022-11-09 | NULL                   |          0 || 2022-11-10 | NULL                   |          0 || 2022-11-11 | Armistice              |          1 || 2022-11-12 | NULL                   |          0 || 2022-11-13 | NULL                   |          0 |[...]| 2022-12-23 | NULL                   |          0 || 2022-12-24 | NULL                   |          0 || 2022-12-25 | Noël                   |          1 || 2022-12-26 | NULL                   |          0 || 2022-12-27 | NULL                   |          0 || 2022-12-28 | NULL                   |          0 || 2022-12-29 | NULL                   |          0 || 2022-12-30 | NULL                   |          0 || 2022-12-31 | NULL                   |          0 |+------------+------------------------+------------+365 rows in set (0,05 sec)

Calendrier des dates de jours fériés

La dernière requête est intéressante : intégrons-la dans une procédure stockée qui prend comme entrée l’année désirée :

DELIMITER //CREATE PROCEDURE cal_fr_public_holiday(IN y YEAR)BEGIN    with recursive cte_current_year as (        select  cast(concat(y, '-01-01') as date) d        union all        select  cast(date_add(d, interval +1 day) as date) d        from    cte_current_year        where   d < concat(y, '-12-31')    ),    cte_name as (        select  d,                 is_fr_public_holiday(d) holiday_name        from    cte_current_year    ),    cte_filter as (        select  d,                holiday_name,                holiday_name is not null is_holiday        from    cte_name    )    select  d `day`,             `holiday_name`     from    cte_filter    where   is_holiday = 1    ;ENDDELIMITER ;

Remarquez que cette-fois-ci je signe la procédure avec le type YEAR et non INTEGER, car certaines fêtes n’ont pas de sens trop loin dans le passé (1er mai, Armistice, etc.)

Exécutons cette nouvelle procédure :

call cal_fr_public_holiday(2022);

Ce qui donne :

+------------+------------------------+| day        | holiday_name           |+------------+------------------------+| 2022-01-01 | Jour de l’an           || 2022-04-17 | Pâques                 || 2022-04-18 | Lundi de Pâques        || 2022-05-01 | Fête des Travailleurs  || 2022-05-08 | Victoire des Alliés    || 2022-05-26 | Ascension              || 2022-06-05 | Pentecôte              || 2022-07-14 | Fête Nationale         || 2022-08-15 | Assomption             || 2022-11-01 | Toussaint              || 2022-11-11 | Armistice              || 2022-12-25 | Noël                   |+------------+------------------------+12 rows in set (0,03 sec)

Cela pourrait être affiné en tenant compte de l’année d’apparition de certains congés. Mais dans la majeure partie des cas, ce code suffira amplement.

Conclusion

Nous avons découvert la très pratique fonction de Jan Weiher retournant la date de Pâques pour une année donnée, puis nous avons créé une autre fonction l’utilisant pour déterminer si une date donnée correspond à un jour férié en France et enfin, nous avons une procédure stockée permettant d’avoir la liste des jours fériés en France pour une année donnée.

Vous n’avez plus d’excuse pour oublier vos jours fériés maintenant !

Déclaration de variables en JavaScript

JavaScript permet de déclarer les variables selon 3 méthodes différentes :

• var myVariable;
• let myVariable;
• const myVariable;

L’utilisation de var est fortement déconseillée maintenant. Préférez l’utilisationde let pour une variable qui pourra être amenée à être modifiée/écrasée et constpour une variable ne devant pas changer.

Et non, l’utilisation de const seul ne suffit pas pour des tableaux de données.Sinon ce serait trop simple.

Pour avoir vraiment un tableau gelé, il faut utiliser également Object.freeze().

L’exemple

Nous allons nous appuyer sur ces quatres déclarations de variables d’un même tableau comportant 3 éléments via les mots-clés let ou const, avec ou sans l’appel de Object.freeze() :

let foo = ['a', 'b', 'c'];const foo = ['a', 'b', 'c'];let foo = Object.freeze(['a', 'b', 'c']);const foo = Object.freeze(['a', 'b', 'c']);

Le code exécuté après chaque déclaration

Le code va tenter :

• de réaffecter le premier item du tableau avec une nouvelle valeur,
• d’ajouter une nouvelle valeur à la fin du taleau,
• de remplacer complètement le tableau par un autre.

Via des console.table() et des try … catch(), nous allons observer ce qui se passe…

Voici le code en question :

try {foo[0] = 'd';} catch(e) {console.log('Fail assigning "d" value on index 0.');}try {foo.push('e');} catch (e) {console.log('Fail pushing new "e" value.');}console.table(foo);try {foo = ['r', 'e', 's', 'e', 't'];} catch (e) {console.log('Fail reassigning variable using full array.');}console.table(foo);

Et maintenant, testons ça !

let seul

Sans trop de surprise, un simple let permet de tout faire sans erreur, pasd’exception levée, et les modifications demandées se sont réalisées.

'd'4+---------+--------+| (index) | Values |+---------+--------+|    0    |  'd'   ||    1    |  'b'   ||    2    |  'c'   ||    3    |  'e'   |+---------+--------+[ 'r', 'e', 's', 'e', 't' ]+---------+--------+| (index) | Values |+---------+--------+|    0    |  'r'   ||    1    |  'e'   ||    2    |  's'   ||    3    |  'e'   ||    4    |  't'   |+---------+--------+

const seul

Avec const, comme pour let, lajout et la modification d’item au sein du tableau est possible.

Par contre, l’affection d’une nouvelle variable à la place du tableau échoue.

'd'4+---------+--------+| (index) | Values |+---------+--------+|    0    |  'd'   ||    1    |  'b'   ||    2    |  'c'   ||    3    |  'e'   |+---------+--------+Fail reassigning variable using full array.+---------+--------+| (index) | Values |+---------+--------+|    0    |  'd'   ||    1    |  'b'   ||    2    |  'c'   ||    3    |  'e'   |+---------+--------+

Avec const, vous préservez le tableau en temps que tel, mais pas son contenu.

let + Object.freeze

Cette fois, il est impossible de modifier ou d’ajouter un item au tableau.

En revanche, il est possible de subtituer le tableau d’origine par un autre…

Ce n’est donc toujours pas une variable 100% immuable.

'd'Fail pushing new "e" value.+---------+--------+| (index) | Values |+---------+--------+|    0    |  'a'   ||    1    |  'b'   ||    2    |  'c'   |+---------+--------++---------+--------+| (index) | Values |+---------+--------+|    0    |  'r'   ||    1    |  'e'   ||    2    |  's'   ||    3    |  'e'   ||    4    |  't'   |+---------+--------+

Notez que le forçage de valeur pour l’index 0 ne soulève aucune erreur et que lavaleur n’est pas écrasée, alors que la tentative d’ajout se solde par la levée d’une exception.

const + Object.freeze

Cette fois, l’utilisation conjointe de const et de Object.freeze() ne permet aucune modification :

• impossible d’jouter un item
• impossible de modifier un item
• impossible de changer la variable dans son ensemble.

Nous avons donc un vrai objet immuable !

'd'Fail pushing new "e" value.+---------+--------+| (index) | Values |+---------+--------+|    0    |  'a'   ||    1    |  'b'   ||    2    |  'c'   |+---------+--------+Fail reassigning variable using full array.+---------+--------+| (index) | Values |+---------+--------+|    0    |  'a'   ||    1    |  'b'   ||    2    |  'c'   |+---------+--------+

Récapitulons

L’utilisation de let, const et Object.freeze() donne un gradient demodifications possibles qui se résume bien dans le tableau suivant :

En fonction de l’usage que vous en aurez, tel ou tel gradient peut mieux convenir.

Le plus clair étant celui qui ne permet pas de modification, avec const et Object.freeze().

Note : Bien que ne parlant que de tableaux, ces résultats sont aussi vrai pour des objets en JavaScript.

Prérequis

Les exemples fournis se basent sur un site web utilisant le serveur web et tournantsous PHP.

Le système d’exploitation est une Ubuntu 18.04.

Est-ce compliqué à mettre en place ?

Oui et non. Tout dépend comment vous allez tirer le meilleur de ce protocole.Si vous voulez juste l’activer pour avoir les performances de base, c’est assezsimple, si vous voulez le push, alors il va falloir réflèchir un peu à ce quidoit être envoyé au client par cette voie (et attention, le push peut apporterplus d’inconvénients que d’avantages).

Prérequis

Il vous faut impérativement le SSL, autrement dit, sans HTTPS, pas de HTTP/2possible, car il nécessite TLS qui est au sein de HTTPS.

Si vous n’avez pas le budget, passer par Let’s encryptpour avoir votre site servi en HTTPS gratuitement. Au passage, si vous appréciezleur service, envisagez de leur faire un don…

Enfin, je vais considérer dans cet article la mise en place de HTTP/2 pour un site en PHP 7.2 servi par Apache 2 sur une Ubuntu LTS 18.04. Si vous avez uneautre configuration :

• Il vous faut Apache version 2.4.24 au minimum, car c’est cette versiond’apache qui supporte pour la première fois le protocole HTTP/2.

• Vous devez utiliser le module PHP FPM, sinon, il sera impossible d’activerle protocole HTTP/2, même si vous le spécifiez en configuration, il resterasur le protocole HTTP/1.1.

Désinstallation des paquets non compatibles

sudo a2dismod php7.2sudo a2dismod mpm_prefork

Installation des paquets compatibles

a2enmod http2apt-get install php7.2-fpma2enmod proxy_fcgi setenvifa2enconf php7.2-fpma2dismod php7.2a2dismod mpm_preforka2enmod mpm_eventsystemctl reload apache2

Ajout du protocole HTTP/2 sur un site

Il suffit d’ajouter cette ligne dans le fichier de configuration d’unVirtual Host, par exemple juste après la ligne d’ouverture de labalise <VirtualHost *:443> :

Protocols h2 http/1.1

Et voilà, en principe, HTTP/2 sera disponible après un systemctl reload apache2.Pour vérifier cela, utilisez les Dev Tools disponibles sur les navigateursweb Firefox ou Chrome.

Considérons avec Firefox l’exemple du chargement de la page Wikipedia sur le protocole HTTP2 :

Félicitation, comme le montre la colonne « Protocole », votre site est maintenantconfiguré pour servir du contenu en HTTP/2.0 !

Et pour nginx ?

Apparemment, dixit spout dans un post sur le forum Web Rank Info, c’est aussi simple que ça :

# changer çalisten 443 ssl;# par ça :listen 443 ssl http2;

Une CTE, c’est quoi ?

Une CTE, ou Common Table Expression est un moyen en SQL d’isoleret de nommer une requête afin de la réutiliser immédiatement dans une autre requête.

Voyons par exemple cette CTE :

WITH very_simple_cte AS (    SELECT 0)SELECT * FROM very_simple_cte;

C’est l’exact équivalent de cela :

SELECT * FROM (SELECT 0) AS very_simple_cte;

Les CTE permettent donc, dans le cas des requêtes imbriquées complexes, d’ensimplifier l’écriture et la lecture.

Mais il n’y a pas que ça ! En effet, il est aussi possible d’avoir desCTE récursives !

Et maintenant, qu’est-ce qu’une CTE récursive ?

Imaginons une CTE assez simple, retournant 2 lignes. Nous pouvons d’abord l’envisager comme suit, avec un UNION en son sein :

WITH simple_cte(x) AS (     SELECT 0     UNION ALL     SELECT 0)SELECT * FROM simple_cte;

Notez le (x). Cela permet de nommer les champs retournés par la CTE.

Nous pouvons aussi faire 2 CTEs et les appeler ensuite en externalisant l’UNION :

WITH simple_cte_bis(x) AS (     SELECT 0)SELECT * FROM simple_cte_bisUNION ALLSELECT * FROM simple_cte_bis;

Bien. Ça peut vite devenir lourd si on a un nombre élevé de lignes devantrespecter un critère dans leur succession… Imaginons que nous souhaitonsgénérer n lignes…

C’est là qu’entre en jeux la récursivité des CTEs !

Pour cela, il suffit d’introduire, lors de la déclaration de la CTE, le mot cléRECURSIVE, mais aussi un garde fou, sinon on tourne en boucle sans fin. Disonsque nous arrêterons la suite au bout de 10 itérations.

WITH RECURSIVE recursive_cte(x) AS (     SELECT  0     UNION ALL     SELECT  x    FROM    recursive_cte    LIMIT   10)SELECT * FROM recursive_cte;

• La première partie de l’UNION définit le point de départ, la première ligne.
• La deuxième partie fait un SELECT simple mais… en appelant la CTE elle-même, et en sélectionnant le champ x déclaré au début.

Ce petit bout de code SQL nous donne en sortie 10 lignes contenant un champ ayantzéro comme valeur.

Voilà, sans le savoir, vous venez de créer votre premier générateur. Basique,soit, mais un générateur tout de même, puisque parti de rien vous avez obtenu10 lignes en sortie.

OK ! Donc, une CTE récursive, c’est un générateur ?

Oui, une CTE récursive est un moyen de créer un générateur.

Pratiquement, les générateurs peuvent servir à générer des suites de nombres, des distributions temporelles (mois, trimestres), ou des alphabets et même d’autres cas encore.

Voyons déjà le cas des générateurs de nombres avec quelques cas simples.

Créons des générateurs de nombres !

Un premier cas simple est tout simplement l’incrémentation de nombres par 1.

Si nous voulons récupérer les nombres de 0 à 15, nous pouvons faire ainsi :

WITH RECURSIVE generator(x) AS (     SELECT 0     UNION ALL     SELECT  x + 1     FROM    generator     WHERE   x < 15 )SELECT * FROM generator;

0123456789101112131415

Mais nous pouvons également faire comme cela :

WITH RECURSIVE generator(x) AS (     SELECT 0     UNION ALL     SELECT  x + 1     FROM    generator     LIMIT   16)SELECT * FROM generator;

Dans chaque cas, la deuxième partie de l’UNION reprend la valeur précédenteet y ajoute 1.

Le garde-fou diffère : soit nous considérons une limitation par rapport à unevaleur du champs calculé, soit nous considérons une limite par rapport au nombrede résultats retournés.

L’utilisation de tel ou tel garde-fou dépendra de chaque cas.

De ce principe d’incrémentation simple, nous pouvons en déduire la conception de nombres avec un pas spécifique.

Mettons que nous souhaitons générer des nombres espacés de 5 à chaque fois, enne dépassant pas la valeur de 100 :

WITH RECURSIVE generator_step(x) AS (     SELECT 0         UNION ALL         SELECT  x + 5     FROM    generator_step     WHERE   x < 100)SELECT * FROM generator_step;

05101520253035404550556065707580859095100

Juste pour le fun, on double à chaque fois…

WITH RECURSIVE generator_double(x) AS (     SELECT 1     UNION ALL     SELECT  x * 2     FROM    generator_double     LIMIT   30 )SELECT * FROM generator_double;

124816326412825651210242048409681921638432768655361310722621445242881048576209715241943048388608167772163355443267108864134217728268435456536870912

Je pense que vous avez compris le principe, beaucoup de suitesmathématiques sont réalisables ainsi. Voyez par exemple la suite de Fibonacci :

WITH RECURSIVE generator_fibo (p, n) AS(     SELECT 0,            1     UNION ALL          SELECT n,            p + n     FROM   generator_fibo     WHERE  n < 100)SELECT  pFROM    generator_fibo;

01123581321345589

Nous pouvons faire mumuse avec les nombres grâce aux générateurs. Faisons maintenant mumuse avec l’alphabet…

Quid des générateurs d’alphabet ?

Vu que les lettres peuvent être codées à partir de code ASCII, alors un générateur d’alphabet est tout aussi possible.

Voyons cela avec l’alphabet latin en générant des lettres majuscules :

WITH RECURSIVE alphabet(code) AS (     SELECT 65     UNION ALL         SELECT  code + 1     FROM    alphabet     WHERE   code < (65 + 25) ) SELECT CHAR(code) FROM alphabet;

Le code ASCII 65 est celui codant pour la lettre A. Les autres suivent dansl’ordre, donc un processus incrémental de un en un suffit. Au final on appliquela fonction CHAR() de SQLite pour avoir la lettre à partir du code.

Cool ! On peut faire plus compliqué ? Avec les dates par exemple…

Oui ! Voyons deux cas pratiques : générer la liste des mois dans une année et la liste des trimestres, avec les bornes de début et de fin.

Commençons par la base : afficher les mois de l’année 1995 (pourquoi pas…).

WITH RECURSIVE by_month(d) AS (     SELECT '1995-01-01'     UNION ALL         SELECT  DATE(d, '+1 MONTHS')     FROM    by_month     WHERE   d < '1995-12-01' ) SELECT * FROM by_month;

1995-01-011995-02-011995-03-011995-04-011995-05-011995-06-011995-07-011995-08-011995-09-011995-10-011995-11-011995-12-01

Jusqu’ici, rien de bien compliqué. Notez l’utilisation de la fonction SQLite DATE(),qui permet de faire des incréments de durées, ici, 1 mois ajouté à la date à chaque fois.

Bien.

Maintenant, vous allez me dire : l’année en dur, c’est bête !

En effet, prenons donc en compte l’année courante :

WITH RECURSIVE by_month(d) AS (     SELECT strftime('%Y', 'now')||'-01-01'         UNION ALL         SELECT  DATE(d, '+1 MONTHS')     FROM    by_month     WHERE   d < (strftime('%Y', 'now')||'-12-01') ) SELECT * FROM by_month;

La fonction SQLite STRFTIME() permet de formater la date courante ('now').Ici, on ne récupère que l’année sur 4 chiffres.

C’est bien, mais on peut faire mieux en ne répétant pas le strftime('%Y', 'now').Pour cela, utilisons le fait qu’il est possible d’avoir plusieurs CTE enchaînéesen définissant cet appel de fonction dans une CTE :

WITH RECURSIVE const AS (    SELECT strftime('%Y', 'now') AS y),by_month(d) AS (     SELECT  const.y||'-01-01'    FROM    const            UNION ALL         SELECT  DATE(d, '+1 MONTHS')     FROM    by_month, const    WHERE   d < (const.y||'-12-01') ) SELECT * FROM by_month;

2021-01-012021-02-012021-03-012021-04-012021-05-012021-06-012021-07-012021-08-012021-09-012021-10-012021-11-012021-12-01

Voilà, en ne se répétant pas, on évite les erreurs stupides.

La CTE const ne sort qu’une seule ligne contenant le champ y stockantl’année en cours sur 4 chiffres.

La CTE by_month utilise la CTE const pour avoir l’année qui est nécessaireà la construction des dates.

Ajoutons-y les bornes définissant les débuts et les fins de mois, avec encorenotre super fonction SQLite DATE() :

WITH RECURSIVE const AS (    SELECT strftime('%Y', 'now') AS y),by_month(d) AS (     SELECT  const.y||'-01-01'    FROM    const        UNION ALL         SELECT  DATE(d, '+1 MONTHS')    FROM    by_month, const    WHERE   d < (const.y||'-12-01') )SELECT  d AS date_start,        date(            d,            'start of month',            '+1 month',            '-1 day'        ) AS date_endFROM    by_month;

2021-01-01|2021-01-312021-02-01|2021-02-282021-03-01|2021-03-312021-04-01|2021-04-302021-05-01|2021-05-312021-06-01|2021-06-302021-07-01|2021-07-312021-08-01|2021-08-312021-09-01|2021-09-302021-10-01|2021-10-312021-11-01|2021-11-302021-12-01|2021-12-31

Voilà ! Nous avons un moyen de générer une liste de chaque mois de l’annéecourante avec les dates de début et de fin de chaque mois.

De la même façon, la réalisation par trimestre en découle (encore merci la fonction DATE() !) :

WITH RECURSIVE const AS (    SELECT strftime('%Y', 'now') AS y), by_trimester(d) AS (     SELECT  const.y||'-01-01'     FROM    const        UNION ALL         SELECT  DATE(d, '+3 MONTHS')     FROM    by_trimester     LIMIT   4 ) SELECT  d AS date_start,        date(            d,            'start of month',            '+3 month',            '-1 day'        ) AS date_endFROM    by_trimester;

2021-01-01|2021-03-312021-04-01|2021-06-302021-07-01|2021-09-302021-10-01|2021-12-31

Voilà ! Nos trimestres sont bien générés avec leurs bornes respectives.

Notre table servant d’exemple

Avoir des générateurs, c’est bien, les utiliser dans quelques cas concrets, c’est mieux.

Notre exemple se basera sur une table comportant des commentaires laissés pardes internautes sur un site.

Un commentaire peut avoir un commentaire parent (dans ce cas, c’est une réponse)sans limitation dans la profondeur de la hiérarchie.

Le login de l’utilisateur, comportant que des caractères ASCII et commençantobligatoirement par une lettre, est enregistré.

La date de création du commentaire est enregistrée.

Voici la table en question :

CREATE TABLE comments (    id          INTEGER PRIMARY KEY UNIQUE,    parent_id   INTEGER REFERENCES comments(id),    author      TEXT NOT NULL                CHECK(author <> '' AND LENGTH(TRIM(author)) > 0),    content     TEXT NOT NULL                DEFAULT '',    created_at  DATETIME NOT NULL                DEFAULT (datetime('now')));

On y injecte tout un tas de données, que vous retrouverez dans le fichier source.

Lister le nombre de commentaires par trimestre

Au premier abord, vous pouvez me dire : « Réalisons juste des GROUP BY et basta ! ».Oui mais non. L’idée est de faire comme un rapport, donc s’il n’y a rien pourune période donnée, le GROUP BY ne le montrera pas. Par contre, si on utilise en plus les CTE vues précédemment pour les mois, alors là ça devient intéressant : il est possible de voir, si, pour un mois, un trimestre, il n’y a rien eu.

Pour notre exemple, nous allons lister le nombre de commentaires laissés pourchaque trimestre. Je vous livre l’exemple tel quel :

WITH RECURSIVE by_trimester(d) AS (     SELECT '2021-01-01'         UNION ALL         SELECT  DATE(d, '+3 MONTHS')     FROM    by_trimester     LIMIT   4 ),comments_by_date AS (    SELECT      created_at    FROM        comments ),borned_trimester AS (    SELECT  d AS date_start,            date(                d,                'start of month',                '+3 month',                '-1 day'            ) AS date_end    FROM    by_trimester)SELECT  t.date_start,        t.date_end,        COUNT(1) AS amountFROM    comments_by_date AS c,        borned_trimester AS tWHERE   strftime('%Y-%m-%d', c.created_at) >= t.date_start        AND        strftime('%Y-%m-%d', c.created_at) <= t.date_endGROUP BY t.date_start;

2021-01-01|2021-03-31|172021-04-01|2021-06-30|42021-07-01|2021-09-30|42021-10-01|2021-12-31|10

Vous reconnaissez les différentes parties ? La CTE des trimestres est prise tellequelle, ainsi que sa partie des bornes, maintenant dans sa propre CTE (orned_trimester).La CTE comments_by_date récupère juste les dates de création des commentaires.

La requête finale utilisant ces trois CTE est assez simple :

• Elle reprend les date de début et de fin de chaque trimestre pour les deux premiers champs.
• Elle compte le nombre d’éléments pour chaque trimestre.
• Le partie WHERE détermine les dates des commentaires devant se trouver dans tel ou tel trimestre.
• Le GROUP BY compacte tout par trimestre, et permet ainsi le calcul du COUNT dans le SELECT pour avoir le nombre de commentaires.

Lister le nombre d’identifiants par ordre alphabétique

Imaginons que, pour des besoins en interne, nous devons lister, pour chaquelettre de l’alphabet, le nombre de commentaires correspondant au login commençantpar cette lettre.

Sans surprise, nous allons reprendre notre CTE alphabet vue plus haut.

À celle-ci, nous ajoutons un autre CTE, qui va récupérer la première lettre dechaque login (via la fonction SUBSTR()) et la passer en majucule (via lafonctionUPPER()), et, dans un autre champ, y placer lenombre de messages qui y correspondent :

SELECT  UPPER(SUBSTR(author, 1,1)) AS letter,        COUNT(*) AS amountFROM    commentsGROUP BY UPPER(SUBSTR(author, 1,1));

Et enfin, une requête exploite ces deux CTE pour afficher l’alphabet avec pourchaque lettre le nombre de commentaires.

WITH RECURSIVE alphabet(code) AS (     SELECT 65         UNION ALL     SELECT  code + 1     FROM    alphabet     WHERE   code < (65 + 25) ),by_authors (letter, amount) AS (    SELECT  UPPER(SUBSTR(author, 1,1)) AS letter,            COUNT(*) AS amount    FROM    comments    GROUP BY UPPER(SUBSTR(author, 1,1)))SELECT      CHAR(code) AS letter,            COALESCE(amount, 0) AS commentsFROM        alphabet AS aLEFT JOIN   by_authors AS b ON b.letter = CHAR(a.code);

A|0B|5C|7D|0E|0F|0G|0H|0I|0J|0K|0L|6M|0N|0O|0P|0Q|6R|1S|9T|0U|0V|1W|0X|0Y|0Z|0

Ainsi, on peut voir que plein de logins ne déposent jamais de message…

Arbre des réponses

Et si, pour chaque ID de commentaire, on afficher son cheminement jusqu’à luiavec le contenu des commentaires parents ?

Pour cela, nous allons nous inspirer de l’article « Chemin d’un nœud dans un arbre hiérarchique de données avec PostgreSQL ».

Nous définissons donc une CTE parents contenant l’ID, le nombre de parents en cours et enfin le contenu.

Un premier jet peut être ceci :

WITH RECURSIVE parents AS (    SELECT  id                          AS id,            0                           AS ancestors,            content                     AS tree    FROM    comments    WHERE   parent_id IS NULL    UNION        SELECT  child.id            AS id,            c.ancestors + 1     AS ancestors,            (                c.tree                 || CHAR(10)                || child.content            ) AS tree    FROM comments as child    INNER JOIN parents c ON c.id = child.parent_id)SELECT id, tree FROM parents;

Ce qui donne une sortie… pas très sexy.

Ce qui serait bien, c’est :

• mettre le nom de l’auteur en première ligne, en majuscules
• mettre le commentaire, tronqué.
• décaler à chaque réponse d’un fil de discussion.
• d’en faire une vue SQL :-)

Allons-y ! Sortons l’arcenal de fonctions disponibles dans SQLite en natif :

• UPPER() pour mettre les auteurs en majuscule
• CHAR(10) pour avoir un retour à la ligne
• SUBSTR() pour tronquer les chaînes de caractères
• PRINTF() pour créer une indentation du texte croissante

Voici le code :

CREATE VIEW comments_tree AS    WITH RECURSIVE parents AS (        SELECT  id                          AS id,                0                           AS ancestors,                UPPER(author)||':'||CHAR(10)||substr(content, 1,50)||'…'  AS tree        FROM    comments        WHERE   parent_id IS NULL        UNION                SELECT  child.id            AS id,                c.ancestors + 1     AS ancestors,                (                    char(10) || c.tree                     || char(10)                     || printf("%"||(2 * (c.ancestors + 1)) || "s", ' ')                     || UPPER(child.author) || ':'                    || char(10)                     || printf("%"||(2 * (c.ancestors + 1)) || "s", ' ')                     || substr(child.content, 1, (50 - (2 * (c.ancestors + 1))))                    ||'…'                ) AS tree        FROM comments as child        INNER JOIN parents c ON c.id = child.parent_id    )    SELECT id, tree FROM parents;

Et voyons, par exemple pour l’ID 29, le fil de discussion :

SELECT tree FROM comments_tree WHERE id = 29;

QUIDAM:Quo vadis?…  CAESAR:  Ego vadam Romam…    SPQR:    Quid??!!!…      SPQR:      Ut a sem ornare tellus faucibus tincidunt a …

Conclusion

Les CTE, c’est pratique, il faut les utiliser sans modération :

• Elles améliorent la lisibilité des requêtes complexes.
• Elles permettent de réaliser des générateurs de données !
• La possibilité d’avoir des CTE récursives, outre le fait de créer des générateurs, permet d’avoir une souplesse et un contrôle supplémentaire sur les jeux de données.
• La syntaxe est largement répendue dans les bases de données modernes.

Attention toutefois : je vous ai exposé ici le cas de SQLite, pour d’autres bases de données, il peut y avoir des moyens plus simples encore que les CTE pour générer des données.

Par exemple, sous PostgreSQL, la fonction generate_series() permet de générer du contenu.

L’ensemble des codes sources de cet article sont disponibles dans ce fichier SQL.

Prérequis

J’utilise dans cet article des exemples utilisant PostgreSQL, mais les principes de base sont adaptables à toutes les bases de données relationnelles.

Je vous montre une version générique (et simplifiée), àadapter selon vos besoins.

Notre exemple

L’exemple utilisé concerne un blog fictif, utilisant les langues disponiblesstockées dans une table languages et stockant la référence des articles dans la table posts.La table t_posts entre en jeu pour tous les champs traduisibles.

Grandes lignes

Le principe est simple : pour chaque entrée dans la table posts, il y a au moins une autre entrée dans la table t_posts comportant des champs traduits dans une langue.

Chaque entrée dans t_posts comporte une clé étrangère obligatoire vers la table posts etune autre également obligatoire vers la table languages, en tâchant de contrôler l’unicité de cette association de clés.

La table stockant les langues supportées

Il est temps de déclarer notre table :

CREATE TABLE languages(    id      SERIAL PRIMARY KEY,    code    TEXT NOT NULL,    name    TEXT NOT NULL    UNIQUE(code));

Remplissons cette table :

INSERT INTO languages(code, name)VALUES      ('fr', 'Français'),            ('en', 'English'),            ('de', 'Deutsch');

Vérifions son contenu :

 id | code |   name   ----+------+----------  1 | fr   | Français  2 | en   | English   3 | de   | Deutsch (3 rows)

Parfait, les langues autorisées pour le site sont correctement en placecomme nous le souhaitions.

La table racine des articles

Définissons maintenant la table stockant les données communes entre chaque versiond’un même article.

Nous allons être simple : nous utiliserons un champ pour le soft delete et unchamp pour la clé primaire. Et c’est tout !

CREATE TABLE posts(    id          SERIAL PRIMARY KEY,    deleted_at  TIMESTAMPTZ);

La table contenant les versions dans différentes langues des articles

Cette table sera plus fournie, car elle devra :

• avoir une référence non nulle vers la table posts
• avoir une référence non nulle vers la table languages
• ne pas avoir de doublon sur l’ensemble des deux clés étrangères ci-dessus
• chaque nouvelle entrée ne sera pas publiée par défaut (brouillon systématique)

Concrétisons cela :

CREATE TABLE t_posts(    id              SERIAL PRIMARY KEY,    post_id         INTEGER NOT NULL REFERENCES posts(id),    language_code   TEXT NOT NULL REFERENCES languages(code),    title           TEXT NOT NULL,    content         TEXT NOT NULL DEFAULT '',    is_published    BOOLEAN NOT NULL DEFAULT 'f',    UNIQUE (        post_id,        language_code    ));

Le problème des entrées fantômes…

Notre façon de séparer les champs liés à une version et le reste, est que nousrisquons de créer des entrées fantômes dans la table posts sans jamais avoirde traductions.

Nous devons donc inclure une sécurité consistant à ne jamais ajouter d’entréedans la table posts sans avoir au moins une entrée créer en même temps dansla table t_posts.

Comment faire cela ?

Soit nous mettons un trigger créant, lors d’une insertion, une entrée dans la tableposts si on ne fourni pas de post_id et balançant cette valeur en tant quepost_id pour l’insertion.

Avantage : se fait de façon transparente et est non bloquant.

Inconvénient : favorise la création de doublons potentiels car on ne se réfère pas à une entrée de la table posts. Celan’empêche également pas la création d’entrées dans la table posts sans au moins un élément traduit dans t_posts.

C’est donc une mauvaise piste.

Soit nous nous facilitons la tâche avec la création de fonctions et un verrouillage empêchant l’ajout directe dans la table posts :

• une fonction pour la création d’un nouveau post dans une langue,
• et une fonction pour l’ajout d’une traduction à un post existant.
• Un trigger sur la table posts pour empêcher toute commande INSERT directement.

Fonction pour l’ajout d’un nouvel article

La fonction prendra le minimum nécessaire pour définir un nouvel article : le titre et le code langue.En retour, la fonction fournit la valeur de la clé primaire de la table posts, afin d’être pratique et de pouvoir enchaîner facilement sur une édition ou l’ajout d’une version dans une autre langue.

CREATE OR REPLACE FUNCTION new_post(    IN arg_title            TEXT,    IN arg_language_code    TEXT)RETURNS INTEGER AS $$DECLARE    pid     INTEGER;BEGIN    INSERT INTO posts (id) VALUES(DEFAULT) RETURNING id INTO pid;     INSERT INTO t_posts (post_id, title, language_code)    VALUES      (pid, TRIM(arg_title), arg_language_code);    RETURN pid;END;$$LANGUAGE plpgsql;

Voilà notre première fonction créée.

Fonction pour ajouter une nouvelle traduction à un article existant

Cette fonction ressemble beaucoup à la précédente, sauf qu’en arguments d’entrées il y en a un supplémentaire pour l’ID de l’entrée dans posts et la valeur de retour est celle de la nouvelle entrée dans la table t_posts, pour pouvoir passer à l’édition tout de suite après par exemple.

CREATE OR REPLACE FUNCTION add_translation_to_post(    IN arg_post_id          INTEGER,    IN arg_title            TEXT,    IN arg_language_code    TEXT)RETURNS INTEGER AS $$DECLARE    tpid     INTEGER;BEGIN    INSERT INTO t_posts (post_id, title, language_code)    VALUES      (                    arg_post_id,                    TRIM(arg_title),                    arg_language_code                )    RETURNING id INTO tpid;    RETURN tpid;END;$$LANGUAGE plpgsql;

Nous avons maintenant ce qu’il faut pour ajouter autant de traduction que nous le permet la table languages.

Trigger interdisant l’ajout direct

Le trigger que nous allons ajouter et appliquer à la table posts lèvera une erreur quand nous tenterons de créerdirectement des entrées dans posts via la commande INSERT et non via la fonction new_post.

En faisant ainsi, il n’y aura pas d’entrées fantômes.

Cette astuce est disponible dans sa version d’origine sur Stackoverflow.

CREATE FUNCTION prevent_natural_insert_on_posts() RETURNS trigger AS $$DECLARE    stack TEXT;    fn    INTEGER;BEGIN    RAISE EXCEPTION 'secured';      EXCEPTION WHEN OTHERS THEN    BEGIN        GET STACKED DIAGNOSTICS stack = PG_EXCEPTION_CONTEXT;                fn := position('new_post' in stack);        IF (fn <= 0) THEN            RAISE EXCEPTION 'Expecting insert from new_post function'            USING HINT = 'Use function to insert data';        END IF;                RETURN new;    END;END $$ LANGUAGE plpgsql;CREATE TRIGGER prevent_normal_insert BEFORE INSERT ON postsFOR EACH ROW EXECUTE PROCEDURE prevent_natural_insert_on_posts();

Testons !

Voyons l’ajout direct sur la table posts, qui doit retourner une erreur :

INSERT INTO posts (id) VALUES (DEFAULT);

Nous obtenons bien un message d’erreur :

ERROR:  Expecting insert from new_post functionHINT:  Use function to insert dataCONTEXT:  PL/pgSQL function prevent_natural_insert_on_posts() line 15 at RAISE

Et un SELECT montre bien que la table posts est toujours vide.

Tentons alors d’ajouter une version à un article qui n’existe pas :

SELECT add_translation_to_post(42, 'It should fail!', 'en');

Et les contraintes ont bien été définies puisque nous obtenons cette erreur :

ERROR:  insert or update on table "t_posts" violates foreign key constraint "t_posts_post_id_fkey"DETAIL:  Key (post_id)=(42) is not present in table "posts".CONTEXT:  SQL statement "INSERT INTO t_posts (post_id, title, language_code)    VALUES      (                    arg_post_id,                    TRIM(arg_title),                    arg_language_code                )    RETURNING id"PL/pgSQL function add_translation_to_post(integer,text,text) line 5 at SQL statement

Maintenant que nous avons fait le tour des contraintes bloquantes, essayons d’entrer du contenu sans erreur en créant un article et en y ajoutant deux autres versions :

SELECT new_post('Vous sortez du secteur américain', 'fr');

Retourne 2 dans mon cas, réutilisons-le :

SELECT add_translation_to_post(2, 'You are living american sector', 'en');SELECT add_translation_to_post(2, 'Sie verlassen den Amerikanischen Sektor', 'de');

Voyons cela :

SELECT * FROM t_posts;

Nous donne :

 id | post_id | language_code |                  title                  | content | is_published ----+---------+---------------+-----------------------------------------+---------+--------------  2 |       2 | fr            | Vous sortez du secteur américain        |         | f  3 |       2 | en            | You are living american sector          |         | f  4 |       2 | de            | Sie verlassen den Amerikanischen Sektor |         | f(3 rows)

Tentons de provoquer une erreur en ajoutant une version qui existe déjà :

SELECT add_translation_to_post(2, 'Hey! I am already here!', 'en');

…et l’erreur est bien levée :

ERROR:  duplicate key value violates unique constraint "t_posts_post_id_language_code_key"DETAIL:  Key (post_id, language_code)=(2, en) already exists.CONTEXT:  SQL statement "INSERT INTO t_posts (post_id, title, language_code)    VALUES      (                    arg_post_id,                    TRIM(arg_title),                    arg_language_code                )    RETURNING id"PL/pgSQL function add_translation_to_post(integer,text,text) line 5 at SQL statement

Conclusion

J’espère que cette façon de gérer les traductions vous sera utile dans l’utilisation que vous faites de votre base de données.

Ce que je vous ai montré est une version simplifiée, généralement un peu plus de contraintes et de cas spéciaux sont présents en pratique. À vous d’adapter les fonctions et les contraintes en fonction de votre situation. Un petit exercice serait de généraliser le trigger empêchant l’insertion directe afin qu’elle fonctionne pour toutes les tables auxquelles elle seraient reliée.

Cet article reprend le flambeau de Des images plus légères avec ou sans perte grâce à Webp, dans le sens ou un nouveau format d’image perce en ce moment avec un niveau de compression encore jamais atteint. Ou presque.

Exemples concrets

J’ai commencé à utiliser ce format sur différents projets, dont mon blog technique que vous lisez en ce moment même.

Plutôt qu’un long discours, voyons ce que son utilisation donne réellement avec ces différents projets.

Le blog

Les images de couverture des articles du blog que vous lisez actuellement :

echo -e "JPEG :" `du -cb source/_posts/*/cover.jpg | tail -n 1`  && \echo -e "WEBP :" `du -cb source/_posts/*/cover.webp | tail -n 1` && \echo -e "AVIF :" `du -cb source/_posts/*/cover.avif | tail -n 1`

Donne :

JPEG : 1840498 totalWEBP : 583496 totalAVIF : 467819 total

Sur un total de 19 images en 800×400px pour chaque format.

• Ici, le format WEBP fait en moyenne 31,7 % la taille du JPEG d’origine. Soit un peu moins du tiers.
• l’équivalent AVIF fait 25,4 % la taille de l’image originale. Soit un quart.

Projet A

Pour un autre projet j’ai 42 images, carrées, de tailles variables pour chaque format avec ceci comme résultat :

echo -e "JPEG :" `du -cb *.jpg | tail -n 1`  && \echo -e "WEBP :" `du -cb *.webp | tail -n 1` && \echo -e "AVIF :" `du -cb *.avif | tail -n 1`

JPEG : 922002 totalWEBP : 299280 totalAVIF : 260945 total

• Ici, le format WEBP fait en moyenne 32,46 % la taille du JPEG d’origine. Presque le tiers.
• l’équivalent AVIF fait 28,30 % la taille de l’image originale. Plus que le quart.

Projet B

Encore un autre projet, ayant 101 images dans chaque format :

JPEG : 9477198 totalWEBP : 2694428 totalAVIF : 2128490 total

• Ici, le format WEBP fait en moyenne 28,43 % la taille du JPEG d’origine. Plus que le quart.
• l’équivalent AVIF fait 22,45 % la taille de l’image originale. Moins que le quart.

Comment je génère mes fichiers AVIF ?

Pour le moment, ImageMagick sur Ubuntu 18.04 ne supporte pas ce format. J’ai donc téléchargé Go AVIF, un petit utilitaire en ligne de commande écrit en Go convertissant des images au format AVIF. Les binaires téléchargeables sont disponibles pour les trois principaux systèmes d’exploitation : Windows, Mac et Linux. Pour les autres systèmes, téléchargez les sources et compilez-les.

Je vous fournis l’aide du programme avif-linux-x64 --help :

Usage: avif [options] -e src_filename -o dst_filenameAVIF encoderOptions:  -h, --help                Give this help  -V, --version             Display version number  -e <src>, --encode=<src>  Source filename  -o <dst>, --output=<dst>  Destination filename  -q <qp>, --quality=<qp>   Compression level (0..63), [default: 25]  -s <spd>, --speed=<spd>   Compression speed (0..8), [default: 4]  --lossless                Lossless compression (alias for -q 0)  --best                    Slowest compression method (alias for -s 0)  --fast                    Fastest compression method (alias for -s 8)

Si vous ne savez pas quoi prendre comme option, contentez-vous juste de convertir avec les options -e et -o pour indiquer le fichier d’entrée et le fichier de sortie. Le résultat obtenu sera déjà très convenable.

Si vous ne voulez pas de perte, ajouter l’option --lossless, pour convertir un PNG par exemple.

Voici pour vous un script Bash très simple pour convertir des fichiers images par lot, à adapter à votre goût :

#!/bin/bashfor img in *.{jpg,jpeg,png,gif}; do    filename=${img%.*}    if [ -f "$filename.avif" ]    then        echo "$filename.avif existe déjà. Pas de conversion."    elseavif-linux-x64 -e "$img" -o "$filename.avif"    fidone

Enregistrez-le dans le fichier nommé to-avif puis changez ses droits pour le rendre exécutable et placez-le au bon endroit :

chmod +x to-avifsudo mv to-avif /usr/local/bin/to-avif

Placez-vous dans un dossier avec plein d’images à convertir et exécutez la nouvelle commande disponible :

cd /mon/dossier/plein/imagesto-avif

Le programme met un peu de temps à tourner, il est très gourmand en ressource.

Comment le format AVIF est-il supporté par les navigateurs ?

À la date de rédaction de cet article, le 12 novembre 2020, le site Can I Use montre une très faible adoption par les navigateurs de ce format. Mais, comme dit plus haut, Google Chrome, un des navigateurs les plus utilisés le supporte depuis la version 85.

Le navigateur Opera suit le choix de Google Chrome depuis la version 71.

Pour Firefox, il faut pour le moment activer un drapeau pour l’avoir depuis la version 77. C’est donc inexistant pour le grand public.

De toute manière, il vous faudra utiliser la balise PICTURE et les balises SOURCE pour avoir une image quel que soit le navigateur :

<picture>    <source srcset="/img/ma-belle-photo.avif" type="image/avif">    <source srcset="/img/ma-belle-photo.webp" type="image/webp">    <img src="/img/mabelle-photo.jpg" type="image/jpeg" alt="Mon texte de secours"></picture>

Pour et contre

Petite note préliminaire : je n’ai utilisé pour le moment que Go Avif, il y a d’autres logiciels disponibles, je ne les ai tout simplement pas encore testés.

Pour

• Le poids des images obtenues est du même ordre que celles obtenues avec le WEBP, en un peu plus léger.
• Ce format est supporté par Google Chrome, le poids lourd du marché des navigateurs.
• Il peut convertir sans perte si on le souhaite (comme WEBP).
• Il peut convertir des images animées GIF par exemple (comme WEBP).
• Il est possible de choisir le niveau de compression et de qualité (comme WEBP)
• Il sera prochainement sur Firefox sans drapeau. Mais quand ?

Contre

• La différence n’est pas si énorme que cela avec le WEBP en utilisant les options par défaut.
• Le convertisseur est très gourmand en ressource lors de la conversion (mais vraiment), alors que le convertisseur WEBP (via ImageMagick ou cwebp) est particulièrement véloce. Pensez-y si vous le mettez sur un serveur web…
• Le convertisseur plante sur des images ayant une trop grande taille.
• Impossible d’afficher l’image AVIF dans Google Chrome hors du contexte d’une page web. Un lien direct vers une image AVIF n’affichera pas l’image, mais forcera son téléchargement.

Mon choix

Je l’utilise de manière expérimentale pour le moment, sur des projets ayant des images de petites à moyennes tailles, et dont on en maîtrise l’ajout (fiabilité et charge processeur me pousse à être très sage). Idéalement, sur un site statique, c’est parfait. La preuve en est avec ce site.

Pour le moment, si vous avez des photos dont vous souhaitez en réduire le poids numérique, alors restez seulement sur du WEBP. Son support est largement répandu sur les navigateurs, les convertisseurs tournent bien et vite, et le poids obtenu est presque équivalent. Ce sera toujours mille fois mieux que du PNG ou du JPEG de base.

Bref, il faut que le support du format AVIF devienne plus mâture et plus répandu. Considérer-le expérimentalement ou dans des environnements parfaitement maîtrisés.