Arrive le jour où l’architecture de l’intranet fait l’objet d’une évolution passant par le changement de domaine : domaine.fr devient intranet.nom.fr. Il va falloir, sur nombre de tables, modifier toutes les adresses e-mail de tous les utilisateurs. Il faudra peut-être gérer, pour certains cas, des adresses e-mail mal orthographiées (domiane.fr), avec une casse différente (DOMAINE.FR), ou, comme j’ai pu le constater récemment sur un bug tracker où les utilisateurs s’inscrivaient eux-mêmes, des domaines totalement différents de celui mis en place (gmail.com)… voire pas de domaine du tout (simple nom d’utilisateur sous la forme prenom.nom) !

La simplicité voudrait que l’on édite le dump de la base de données avec son éditeur de texte favori (Notepad++ sur Windows, vi sous Linux… en ce qui me concerne) et que l’on fasse les modifications avec une fonction de remplacement de texte. Seulement, l’hétérogénéité des adresses e-mail enregistrées et surtout la taille du dump sont deux freins non négligeables à cette solution. Ouvrir un dump de 1 Go avec Notepad++ ? Impensable ! Exporter uniquement les tables où figurent les adresses e-mail, puis ensuite les réinjecter ? Pourquoi pas, mais en fonction des outils mis en place sur l’intranet, cette méthode peut se réveler fastidieuse. Modifier manuellement dans la table les adresses e-mail ? Oui pour quelques utilisateurs, non pour plusieurs dizaines voire centaines d’utilisateurs.

Il y a une solution simple, efficace et rapide avec MySQL. Démonstration :

mysql> DESC users;
+-------+-------------+------+-----+---------+-------+ 
| FIELD | TYPE        | NULL | KEY | DEFAULT | Extra |
+-------+-------------+------+-----+---------+-------+ 
| email | VARCHAR(50) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+ 
1 ROW IN SET (0.05 sec)
 
 
mysql> SELECT * FROM users;
+-------------------------------+ 
| email                         |
+-------------------------------+ 
| sergent.bellec                |
| capitaine.flamme@DOMAINE.FR   |
| lieutenant.columbo@domaine.fr |
| colonel.moutarde@youpi.fr     |
+-------------------------------+ 
4 ROWS IN SET (0.05 sec)
 
 
mysql> UPDATE users SET email=concat(substring_index(email,'@',1),'@intranet.nom.fr');
Query OK, 4 ROWS affected (0.00 sec)
ROWS matched: 4  Changed: 4  Warnings: 0
 
 
mysql> SELECT * FROM users;
+------------------------------------+ 
| email                              |
+------------------------------------+ 
| sergent.bellec@intranet.nom.fr     |
| capitaine.flamme@intranet.nom.fr   |
| lieutenant.columbo@intranet.nom.fr |
| colonel.moutarde@intranet.nom.fr   |
+------------------------------------+ 
4 ROWS IN SET (0.00 sec)

Explications :

- La fonction substring_index permet de découper la valeur d’un champ avec un délimiteur ;
- La fonction concat permet de concaténer (ah bon ?) deux éléments.

Grâce à ces deux fonctions, la requête récupère pour chaque utilisateur la partie avant l’arobase, y ajoute la valeur « @intranet.nom.fr » et met à jour le champ. Tout simplement.

mysql> select * from t1;
+------+------+
| c1   | c2   |
+------+------+
|    1 | aaa  |
|    2 | bbb  |
|    3 | ccc  |
|    4 | ddd  |
|    5 | eee  |
+------+------+
5 rows in set (0.00 sec)
 
mysql> select @total := COUNT(*) as "@total" from t1;
+--------+
| @total |
+--------+
|      5 |
+--------+
1 row in set (0.01 sec)
 
mysql> select * from t1 where c1 = @total;
+------+------+
| c1   | c2   |
+------+------+
|    5 | eee  |
+------+------+
1 row in set (0.01 sec)

Il est également possible d’affecter directement une valeur à une variable :

mysql> select * from t1;
+------+------+
| c1   | c2   |
+------+------+
|    1 | aaa  |
|    2 | bbb  |
|    3 | ccc  |
|    4 | ddd  |
|    5 | eee  |
+------+------+
5 rows in set (0.00 sec)
 
mysql> set @valeur = 4;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from t1 where c1 = @valeur;
+------+------+
| c1   | c2   |
+------+------+
|    4 | ddd  |
+------+------+
1 row in set (0.00 sec)

Notez que dans ce cas, il faut utiliser simplement le signe « = » et non « := » comme précédemment.

Un exemple d’utilisation concrète : comment faire pour qu’une table aux clés primaires décousues (1,3,8,14,15…) soit de nouveau bien ordonnée (1,2,3,4,5…) ^[1] ? Sélectionner chaque entrée de la table et l’ajouter dans une autre table ? C’est lourd… Faire une boucle et envoyer une instruction UPDATE pour chaque entrée de la table ? C’est lourd…

MySQL le fait avec seulement une variable et une requête :

mysql> select * from t1;
+------+------+
| c1   | c2   |
+------+------+
|    1 | aaa  |
|    3 | bbb  |
|    8 | ccc  |
|   14 | ddd  |
|   15 | eee  |
+------+------+
5 rows in set (0.00 sec)
 
mysql> set @valeur = 0;
Query OK, 0 rows affected (0.00 sec)
 
mysql> update t1 set c1 = @valeur := @valeur + 1;
Query OK, 4 rows affected (0.00 sec)
Rows matched: 5  Changed: 4  Warnings: 0
 
mysql> select * from t1;
+------+------+
| c1   | c2   |
+------+------+
|    1 | aaa  |
|    2 | bbb  |
|    3 | ccc  |
|    4 | ddd  |
|    5 | eee  |
+------+------+
5 rows in set (0.00 sec)

[1] : avec un champ auto-incrémenté et des instructions DELETE à répétition, on a vite fait de se retrouver dans ce genre de situation.

Il existe pourtant un paramètre à passer dans la commande de lancement MySQL afin de désactiver cette fonction : -b.

Ce paramètre figure dans l’aide de la commande mysql, mais semble visiblement peu connu… malgré son utilité.

Pensez donc à lancer MySQL de cette façon :

C:\> mysql -b -h serveur -u identifiant -p

Vos voisins vous remercieront, et vous n’aurez plus à craindre d’être agressé à chaque erreur dans votre requête SQL…