J’ai déjà expliqué comment modifier l’emplacement des données d’un serveur MySQL mais cette fois-ci on va aller encore plus loin :

• on ne va pas toucher aux fichiers de configuration par défaut
• on va pouvoir conserver toute notre configuration sur une partition séparée
• on va être tranquille pour les éventuelles futures réinstallations

C’est pas très compliqué à mettre en œuvre et au final, tout le monde y gagne !

Organisation du répertoire /home

Le titre de l’article le suggère bien, cet article se consacre à la configuration des serveurs et programmes suivants :

• Apache 2
• PHP 5
• MySQL 5
• AppArmor (installé et activé par défaut depuis Ubuntu 8.04)

Pour des raisons évidentes de facilité, j’ai donc créé un répertoire qui rassemble toutes mes configurations spécifiques. En voici son arborescence :

• ~/config
  • /apache2
    • sites-available
      • 000-default-custom
      • local.monprojet.com
      • etc.
  • /apparmor
    • usr.sbin.mysqld-custom
  • /mysql
    • my-custom.cnf
  • /php5
    • php-custom.ini

Nous écrirons dans ces fichiers uniquement les points de configuration que l’on souhaite adapter. C’est plus simple à maintenir. Qui plus est, si les fichiers de configuration sont mis à jour par leur serveur respectif, nos fichiers resteront à l’abri.

Un des moto de Debian c’est la configuration à base de fichiers. Vous trouverez régulièrement des répertoires ayant un nom suivant le motif application.d. Donc plutôt que d’avoir 1 seul fichier de configuration, on a 1 fichier initial plus des configurations additionnelles dans ces fameux répertoires « .d ».

Configuration d’Apache

Pour Apache la démarche est la suivante :

1. créer les Virtual Host dans son répertoire personnel
2. lier les fichiers dans sites-available
3. activer les sites à l’aide de la commande a2ensite
4. recharger Apache

La seule étape par rapport à d’habitude c’est qu’on ne crée par les Virtual Host directement dans /etc/apache2/sites-available et qu’on les lie depuis notre répertoire personnel.
Admettons que je souhaite créer un Virtual Host pour une instance locale de mon blog. Je vais procéder ainsi :

1. gedit ~/conf/apache2/sites-available/local.case.oncle-tom.net
   J’y ai placé une configuration somme toute minimaliste :

   <VirtualHost *:80>
   ServerName local.case.oncle-tom.net
   DocumentRoot /home/oncletom/workspace/case.oncle-tom.net
   ErrorLog /var/log/apache2/error.case.oncle-tom.net.log
   LogLevel warn
   CustomLog /var/log/apache2/access.case.oncle-tom.net.log combined
   ServerSignature On
   </VirtualHost>

2. sudo ln -s ~/conf/apache2/sites-available/local.case.oncle-tom.net /etc/apache2/sites-available/local.case.oncle-tom.net
3. sudo a2ensite local.case.oncle-tom.net
4. sudo service apache2 reload

On se fendra de l’ajout d’un hôte local dans le fichiers hosts pour coller au plus près à l’instance de production. Toutefois je ne connais pas d’autre moyen que de modifier le fichier d’origine :-/ Si vous avez une solution je suis preneur.

Configuration de MySQL

Pour MySQL c’est un peu plus compliqué car on va également en profiter pour déplacer l’emplacement par défaut des données. Pourquoi ? Pour les placer sur une partition qui ne craindra pas les formattages et les réinstallation système.
Si vous aviez déjà suivi ma procédure de déplacement des données MySQL : oubliez là. Celle-ci est largement plus aboutie.

Avant de se jeter à corps perdu dans les manipulations, voici la démarche entreprise :

1. créer le fichier de configuration MySQL
2. créer le répertoire qui accueillera les données MySQL
3. lier la base mysql d’origine
4. modifier la configuration d’AppArmor
5. recharger la configuration des serveurs AppArmor et MySQL

C’est déjà un peu plus long mais là encore, il n’y a pas grand chose à faire en fin de compte :

1. gedit ~/conf/mysql/my-custom.cnf
   On y indique le nouvel emplacement de ses données MySQL :

   [mysqld]
   datadir            = /home/oncletom/Apps/mysql

2. mkdir /home/oncletom/Apps/mysql
   sudo chown mysql:mysql /home/oncletom/Apps/mysql
3. ln -s /var/lib/mysql/mysql /home/oncletom/Apps/mysql/mysql
4. sudo gedit /etc/apparmor.d/usr.bin.mysql
   J’y ai remplacé

   /var/lib/mysql/ r,
   /var/lib/mysql/** rwk,

   par l’ancien chemin + le nouvel emplacement des données MySQL

   /var/lib/mysql/ r,
   /var/lib/mysql/** rwk,
   /home/oncletom/Apps/mysql/ r,
   /home/oncletom/Apps/mysql/** rwk,

5. sudo service apparmor reload && sudo service mysql reload

Si vous avez bien suivi toutes mes explications, vous vous demanderez pourquoi j’ai modifié le profil existant de MySQL dans AppArmor au lieu de lier un nouveau profil ?
Je me suis rendu compte qu’au démarrage de l’OS, AppArmor ne chargeait pas le profil personnalisé et bloquait le démarrage de MySQL. J’ai créé un sujet sur Ubuntu Forums après une lecture de la documentation AppArmor mais pas de nouvelles. Là aussi je suis preneur car en relançant les serveurs à la main, tout fonctionne.

Ensuite à vous de repeupler vos bases de données à partir d’un dump. Si vous procédez à un déplacement des répertoires, n’oubliez pas de tout préserver : propriétaire et permissions ! Ça se passe avec l’option -a de cp par exemple.

Configuration de PHP

Fort heureusement pour PHP c’est plus simple puisqu’il n’y a qu’un seul petit lien symbolique à faire.
À noter que la configuration modifiée sera répercutée sur toutes les configurations de PHP, que ça soit pour Apache, en CLI ou CGI.

1. gedit ~/conf/php/my-custom.ini
   J’ai ai mis par exemple :

   memory_limit = 64M

2. sudo ln -s ~/conf/php/my-custom.ini /etc/php5/conf.d/my-custom.ini

Et voilà c’est tout pour PHP. Il faut bien entendu recharger votre serveur Web (Apache ou Lighttpd par exemple) pour qu’ils prennent en compte la modification.

Conclusion

J’ai déjà appliqué cette méthode par 2 fois et que dire si ce n’est que tout va plus vite ainsi !
Vos fichiers de configuration restent accessibles depuis votre gestionnaire de fichiers (pas besoin de passer en sudo pour sauvegarder les changements). Ils sont préservés de toute réinstallation impromptue.

Vous ne touchez que de manière minimaliste aux fichiers de configuration d’origine :

• /etc/hosts pour ajouter un nom d’hôte (utile seulement si vous ne souhaitez pas utiliser localhost)
• /etc/apparmor.d/usr.bin.mysql pour la raison évoquée plus haut … sinon on s’en serait passé

J’ai cherché à faire pareil avec phpmyadmin mais il ne semble pas y avoir de mécanisme de ce type. Dommage.

J’imagine qu’il doit y avoir des moyens similaires avec d’autres serveurs et d’autres langages. Vous procédez à un reparamétrage systématique ou bien vous utilisez une technique de ce genre ?

L’installation par défaut d’un serveur MySQL est suffisante pour être opérationnel dans la minute qui suit. Elle ne facilite en revanche pas la maintenance en laissant le répertoire contenant vos bases de données et tables hors de portée.

L’intérêt de choisir soi-même l’emplacement de ce répertoire, le datadir, est double :

• regrouper les données en un endroit connu (facilite les sauvegardes)
• utiliser le partitionnement du disque pour ne pas avoir à craindre une perte de données en cas de réinstallation du système (facilite la maintenance)

Nous allons voir comment procéder à ce changement tout en adaptant les sécurités des systèmes tels que SELinux et AppArmor. Ces derniers empêcheront en effet le serveur de démarrer.

Remarque importante : j’ai publié une version améliorée du déplacement des données d’un serveur MySQL. Je la recommande par rapport à cet article : elle implique moins de manipulations et est plus propre.

Quelques généralités avant de commencer

Quitte à changer l’emplacement du datadir, autant le déplacer sur une partition qui ne sera pas effacé lors de la réinstallation de votre système d’exploitation, que ça soit du Linux, MacOS ou Windows.

Personnellement, sous Ubuntu/Debian, je crée un répertoire dans /home qui s’appelle mysql. Mon répertoire /home est bien entendu monté sur une partition différente. Si ce n’est pas le cas chez vous, pensez à déplacer votre /home.

sudo mkdir /home/mysql
sudo chown mysql:mysql /home/mysql

Enfin, dernier détail à connaître : l’emplacement de vos données MySQL :

• sous Linux, généralement : /var/lib/mysql
• sous Windows, avec WAMP : C:Program FilesWampmysqldata

Méthode 1 : modifier la configuration MySQL

C’est probablement la méthode la plus simple mais elle a l’inconvénient d’avoir à modifier un fichier de configuration. Il faut donc modifier la propriété datadir de votre fichier de configuration MySQL :

• sous Linux, généralement : /etc/mysql/my.cnf
• sous Windows, avec WAMP : C:Program FilesWampmysqlconfmy.ini

Dans ce fichier se trouve une section consacrée à la configuration générale du serveur mysql (mysqld pour mysql daemon) :

[mysqld]
user            = mysql
port            = 3306
basedir         = /usr
datadir         = /var/lib/mysql
tmpdir          = /tmp

J’ai mis en gras la ligne qui nous intéresse, à savoir le datadir.
Quelle valeur mettre ? Celle de l’emplacement souhaité pour vos données. Dans mon cas ça aurait été /home/mysql :

datadir         = /home/mysql

Vous vous assurerez d’avoir bien stoppé le service MySQL, d’avoir copié/collé vos données de l’ancien emplacement vers le nouveau et enfin de redémarrer MySQL. C’est seulement en cas de réussite que vous pourrez supprimer l’ancien répertoire

sudo -s
/etc/init.d/mysql stop
cp -pr /var/lib/mysql/* /home/mysql
/etc/init.d/mysql start

Méthode 2 : utilisation d’un lien symbolique

La documentation de MySQL explique l’utilisation des liens symboliques pour tout, une base de données précises voire même les tables. Ceci dit nous allons voir l’exemple global : on déplace tout.

Concrètement cette méthode consiste à :

1. stopper le service MySQL
2. déplacer le répertoire de données (au cas où)
3. créer le lien symbolique
4. copier les données dans le nouvel emplacement
5. relancer le service MySQL

Concrètement, ça se traduit comme ceci :

sudo -s
mv /var/lib/mysql /var/lib/mysql-old
ln -s /home/mysql /var/lib/mysql
cp -pr /var/lib/mysql-old/* /home/mysql
/etc/init.d/mysqld start

Là encore, supprimez la copie de vos données (répertoire mysql-old) seulement en cas de succès. Ça facilite les retours en arrière en cas de pépin.

Cas particulier : systèmes employant AppArmor ou SELinux

Il y a cependant un hic possible si vous utilisez une distribution Fedora ou Ubuntu, surtout depuis sa version Hardy Heron (8.04). Celle-ci intègre une sécurité pour éviter à certains services critiques d’être altérés par une manipulation extérieure … comme la notre.

Il faut savoir que les 2 méthodes du haut échoueront si vous rentrez dans ce cas de figure : le service MySQL ne démarre pas.
Pas de panique, il y a juste un fichier à modifier : /etc/apparmor.d/usr.sbin.mysqld. Il y a un passage ressemblant à ceci, dans le cas d’AppArmor et Ubuntu :

/etc/mysql/*.pem r,
/etc/mysql/conf.d/ r,
/etc/mysql/conf.d/* r,
/etc/mysql/my.cnf r,
/usr/sbin/mysqld mr,
/usr/share/mysql/** r,
/var/lib/mysql/ r,
/var/lib/mysql/** rwk,
/var/log/mysql/ r,
/var/log/mysql/* rw,
/var/run/mysqld/mysqld.pid w,
/var/run/mysqld/mysqld.sock w,

Vous voyez le loup venir. Il suffit de remplacer les occurences de /var/lib/mysql par le chemin de votre nouvel emplacement, /home/mysql dans notre cas :

/home/mysql/ r,
/home/mysql/** rwk,

La raison de cette modification est presque simple : AppArmor ne suit pas les liens symboliques. Il considère que /var/lib/mysql est différent de /home/mysql et que ce dernier ne concerne pas le service mysqld.
Notre modification évite ce blocage et permet du même coup au serveur MySQL de démarrer ; les échecs étant dus au fait que le serveur ne trouvait pas de base à charger (dont la sienne, mysql).

Pour terminer, on peut relancer les 2 services, apparmor et mysqld :

sudo /etc/init.d/apparmor restart
sudo /etc/init.d/mysqld restart

Conclusion

Nous avons vu 2 méthodes pour rendre sa gestion des bases de données plus souple et plus sure. En cas de défaillance système – ça arrive même aux meilleurs – il faut pouvoir le réinstaller sans craindre de perdre des données vitales. Et les bases de données le sont.

On peut aussi constater que les nouveaux services de protection peuvent compliquer la vie si on ne les sait pas actifs et si on ne comprend pas leur fonctionnement. J’ai passé plusieurs heures à comprendre pourquoi le serveur MySQL ne se relançait pas alors qu’il me semblait avoir effectué la même manipulation sur les précédentes versions d’Ubuntu.

N’hésitez pas à partager votre méthode ou apporter vos suggestions sur votre gestion des datadir.

Google est une société à la fois adulée et pointée du doigt. La moindre nouveauté résonne sur l’étendue du Web, louée par ses défenseurs, critiquée par ses détracteurs.
Au-delà de ces querelles insipides et totalement subjectives, qu’est-on en droit de penser de Google ?

Aujourd’hui nous confions notre vie à Google avec plus ou moins de visibilité : données personnelles, emails, mots de passe, habitudes comportementales, organisation professionnelle et j’en passe. Est-ce parce que c’est écrit Google que l’on peut dormir tranquille ?

Quels intérêts à confier sa vie à Google ?

Des services qui justifient leur taux d’adoption

Rendons à César ce qui appartient à César : de nombreux services Google sont exemplaires et méritent d’être utilisés. Difficile de ne pas faire état du moteur de recherche, LE service qui a révélé Google au monde entier et sur lequel il a basé tout le reste de sa stratégie. Il n’est peut-être pas pertinent sur toutes les recherches (d’où l’intérêt d’avoir un choix de moteurs) mais il faut bien avouer que ses réponses cadrent bien avec les requêtes.
Bilan des courses ? Un moteur employé à hauteur de 90% en Europe ; chiffre qui devrait être atteint fin 2008/début 2009 aux États-Unis.

Comment continuer sans parler de Gmail (emails), Google Maps (cartographie et itinéraires), Google Calendar (agenda), Google Reader (lecteur de contenus syndiqués), Google Apps (solution collaborative pour son propre nom de domaine), Blogger (blogs) et Google Analytics (mesure d’audience), entre autre.

Tous ces services, on aurait du mal à les quitter du jour au lendemain, d’autant plus qu’ils sont gratuits. C’est peut-être à ça que l’on reconnaît un produit indispensable : il améliore notre quotidien et ne représente pas une contrainte.

Des services tournés vers l’utilisateur

En plus d’excellents services, Google se paie aussi le luxe de concevoir leurs interface avec brio. C’est ce qu’on pourrait simplexité : une interface simple qui se complexifie sur demande en fonction des besoins.
Vous vous souvenez également avoir cliqué sur message de confirmation pour supprimer, archiver ou déplacer des emails ? Non : à la place vous avez un message Annuler qui s’affiche une fois l’action effectuée. C’est le fameux undo et c’est génial car il permet de se tromper tout simplement. Avec ce procédé, l’erreur est permise puisqu’on peut revenir en arrière. Ce qui n’est pas le cas avec un Êtes-vous sûr ? Oui / Non …

Leurs interfaces ne sont pas forcément belles, ne proposent pas d’effets graphiques de furieux mais elles sont claires, lisibles et fonctionnelles. En d’autres termes elles sont ergonomiques et pratiques.

Une raison de plus d’utiliser des services Google.

La gratuité n’a pas de prix

Pourquoi payer quand on peut avoir quelque chose gratuitement ? Cet adage habille très bien Google puisque tous les services grand public sont gratuits (avec éventuellement quelques options payantes). Je me souviens encore des railleries au lancement de Gmail : 1Go pour ses mails ? Ça sert à rien.
Il n’empêche que pour bénéficier d’une telle capacité à l’époque il fallait mettre la main à la poche. Et effectuer une recherche pour trouver un email datant de 3 ans ça n’a pas de prix … ou plutôt si ça en un : c’est cher, très cher. Mais pas pour Google. Maintenant qui cracherait sur son archivage d’emails ?

Cette gratuité n’est pas de la philanthropie de la part de Google (la Fondation Google est là pour ça). Tout ceci repose quasiment exclusivement sur la publicité. Plus Google affiche de publicités et plus Google gagne de l’argent.
Google Adsense est un véritable cheval de Troie puisque la régie publicitaire va jusqu’à s’imposer sur la majorité des sites du monde entier et … rapporte de l’argent à ses utilisateurs.

En clair, utiliser Google est gratuit mais permet même de générer des revenus. Elle est pas belle la vie ?

Une innovation qui hisse le Web

Une autre raison de soutenir Google et/ou d’utiliser ses services est en rapport avec la dynamique que le géant a su insuffler au Web : l’innovation. Le grand réveil est apparu avec l’introduction de Gmail et par la suite, de Google Maps. Ces 2 services ont été le catalyseur de ce qui a été bêtement appelé « Web 2.0″. Le Web était tout simplement passé de l’enfance à l’adolescence.

Par delà cet aspect visible, il y a également un travail de l’ombre avec des contributions à des projets libres tels que Mozilla Firefox, Wine ou encore MySQL. Google utilise ces produits et redistribue ses contributions par rapport à son utilisation.
En fournissant une forge nommée Google Code, Google permet aussi à des projets de naître en leur fournissant une infrastructure, certes limitée, à moindre coût.

De quoi est-on en droit de se méfier ?

Don’t be evil

Tout ceci paraît bien évidemment idylique : Google est beau, Google est grand, Google est fort. Son slogan est même Don’t be Evil. Ne sois pas mauvais. Sauf que mauvais, Google l’est quelques fois. Notoriété oblige, tout problème est amplifié, à tort ou à raison et se termine parfois en polémique obligeant Google à faire marche arrière.

Des exemples ? La controverse Google Reader et des amis, le scandale AFP/Google News, l’indexation des livres avec Google Books (anciennement Google Print), la sortie de Google Web Accelerator, les clauses abusives de Google Sites ou encore les failles Gmail sources de fraudes (n’utilisez jamais ces formulaires demandent login et mot de passe par pitié).

On ne peut pas dire que la communication de Google à ce niveau aie été exemplaire ni … entendue.

Une communication destructurée

En y réfléchissant, qui sait ce que Google va lancer dans 1, 2, 3 ou 6 mois ? Pas grand monde. Si on sait que le Master Plan est la clé de tout, toujours est-il qu’on ne sait pas et qu’en dehors des annonces de produit, Google cultive le mystère.

Cette stratégie a beau limiter au maximum les plagiats de la concurrence mais ça limite également grandement la visibilité sur les objectifs de Google. Aux questions Quand est-ce qu’un service sera amélioré ?, Quel service a été arrêté ? ou encore La faille a-t-elle été corrigée, vous apprendrez bien souvent les réponses à vos dépends.

Cette communication du blackout est problématique pour une société censée … agréger et traiter l’information. Je pense qu’un peu de transparence et une meilleure organisation de l’information interne à Google lui éviterait quelques déboires et des inquiétudes de la part d’utilisateurs.

À la merci d’une politique obscure

Quand on aime, on ne compte pas. Et on se retrouve avec une majorité de produits Google dans notre quotidien.
Ces produits sont nombreux, variés et certains sont totalement inconnus. C’est comme ça que certains produits ferment du jour au lendemain sans qu’on sache trop pourquoi si ce n’est qu’ils sont peu utilisés.

Attention à ne pas prendre de raccourci : quand on lance beaucoup de services il est normal que certains meurent. Pourtant à côté de ça certains subsistent alors qu’ils sont pestiférés (Google Directory ou Google Web Accelerator). On ne sait jamais QUAND ça va arriver, on ne sera jamais prévenu AVANT. Difficile de baser un produit dessus ou d’en faire une fonctionnalité sur son propre site avec une telle politique.
Votre épicier vous prévient avant de partir en congès alors pourquoi pas Google ?

Le pire c’est peut-être quand on n’utilise pas Google mais une société que Google rachète : les clients d’Urchin et de GrandCentral se mordent encore les doigts de ces acquisitions. À peine rachetés, ces services ont été fermés/non-maintenus. Il aura fallu attendre 3 ans pour qu’une nouvelle version du logiciel Urchin sorte … en beta. C’est d’autant plus problématique que c’était le logiciel de sa catégorie le plus abouti.

Conclusion

Je ne fais pas partie de ceux qui adulent corps et âme Google.
Je ne fais pas non plus partie de ceux qui lui crachent dessus systématiquement.

Je suis un utilisateur de Google qui apprécie ses produits pour ce qu’ils sont, pour leur utilité et leur conception. À juste titre je me sens concerné par l’attitude de la société. Parler à des millions d’utilisateurs n’a rien de facile je le concède largement mais un développeur travaillant avec des outils Google, une société travaillant avec des outils Google ou même un utilisateur employant avec des outils Google ne devrait craindre la fermeture d’un service et la perte des données qui s’ensuit.
Google applique des principes d’ergonomie astucieux sur ses interfaces. Cela devrait être la même chose avec ses clients. Une trop grosse partie du Web repose sur Google pour que celui-ci ne se permette de devenir evil, ne serait-ce qu’un peu.

À l’heure actuelle la bulle Google a perdu de sa stature avec une action malmenée en Bourse, des services qui évoluent peu/pas et un attentisme important vis à vis d’Android (système d’exploitation sur téléphone mobile) et d’OpenSocial (réutilisation des données entre sites pour éviter de vous recréer sempiternellement vos listes d’amis, entre autre). Ce dernier a été annoncé au moment où Facebook volait la vedette au journal de 20H. Qu’en est-il maintenant que la starification est retombée ?

Il est important d’avoir un regard critique sur les services employés et sur les méthodes pratiquées. Être fan d’un produit est aujourd’hui dangereux si c’est pour être enfermé par celui-ci. On en paie aujourd’hui les conséquences avec Internet Explorer, par exemple, devenu un véritable fardeau pour Microsoft dans sa version 6. Tout le Web aimerait s’en débarasser. Mais beaucoup se sont basés dessus et exclusivement dessus.
L’Histoire peut très bien se répéter avec une situation monopolistique de Mac qui a la fâcheuse habitude d’enfermer ses utilisateurs en verrouillant et protégeant à n’en plus finir.

La majorité des systèmes de bases de données permettent de trier une sélection de données en fonction de nos besoins, souvent de manière simple. La majorité des besoins courants impliquent des tris ascendants ou descendants (comprendre « par ordre alphabétique croissant ou descendant ») sur une plusieurs colonnes (des dates, des titres ou des codes particuliers) mais de temps à autre, il arrive que les besoins soient plus complexes puisque l’on voudra soit :

• un ordre aléatoire
• un ordre bien précis, ni ascendant ni descendant

Le mécanisme de tri (ORDER BY)

Pour bien comprendre comment fonctionne en détail la commande ORDER BY, je vous invite à lire la documentation concernant les optimisations relatives à ORDER BY. Ce que l’on doit en retenir :

1. le tri est effectué sur les données filtrées par un éventuel WHERE ;
2. il y a 2 algorithmes de tri : l’un utilisant deux passes, l’autre n’utilisant qu’une passe mais davantage de mémoire ;
3. l’algorithme en une passe n’est pas valable pour des tris sur des données de type TEXT ou BLOB ;
4. un tri sur un index est largement plus rapide et plus performant que sur des valeurs non-indexées

Lorsqu’on veut trier des données, il vaut donc mieux écrémer au mieux la plage de données grâce à de judicieux filtres WHERE et de préférence, sur des colonnes indexées.

Mais revenons à nos moutons.

Tri aléatoire (ORDER BY RAND())

Deux solutions s’offrent au développeur pour effectuer un tri aléatoire : recueillir les données voulues et les trier via langage de programmation (sort(), ksort() etc.) ou alors trier directement à la source via la base de données.
Si les bases de données portent leur nom, c’est bien parce qu’elles sont performantes dans leur travail donc autant leur laisser celui-là, celui du tri aléatoire, qui sera bien plus rapide et performant, surtout sur des volumes importants de données.

Cette solution est relativement connue, ORDER BY RAND() mélange les données recueillies de manière totalement aléatoire, sans tenir compte des index ni de quoi que ce soit d’autre. Pensez à utiliser une clause LIMIT si vous ne voulez récupérer qu’un nombre défini de lignes.

SELECT * FROM `ma_table` ORDER BY RAND() LIMIT 1 ;

Cette instruction prendra une ligne et une seule, au hasard. Rapide, concis et efficace.

Tri personnalisé (ORDER BY FIELD())

Pire que le tri aléatoire, il y a celui du tri personnalisé, celui qui n’est ni ascendant, ni descendant, ni aléatoire : on veut un ordre précis. Imaginons que nous nous trouvions avec la table suivante :

Comment faire pour récupérer la liste des jours de semaine dans l’ordre de notre choix ? Tout simplement en utilisant la fonction FIELD() (depuis MySQL 4) :

SELECT jour_nom
FROM `dates_semaine`
ORDER BY FIELD( jour_id, 'lun', 'mar', 'mer', 'jeu', 'ven', 'sam', 'dim' ) ;

J’aurais tendance à dire que la requête parle d’elle-même : on spécifie un tri sur le champ jour_id dans l’ordre passé dans les paramètres suivants.
Ce qui est intéressant dans notre cas c’est qu’on peut donc gérer des semaines débutant le jeudi, le samedi, le dimanche ou le lundi (histoire de coller avec tous les calendriers existants). Seuls les paramètres à donner à la requête changeraient.
C’est également intéressant pour trier le résultat d’une requête en fonction de l’ordre des lignes d’un fichier qui aurait été uploadé sur un serveur.

Conclusion

La clause ORDER BY est plus puissante qu’il n’y paraît. Elle est garante de l’ordre des résultats retournés. Si dans certains cas l’ordre n’a pas d’importance, le contraire peut également être valable. Et c’est précisément dans ce cas que l’on aime à pouvoir manipuler les données comme on l’entend.
Il existe d’autres possibilités intéressantes en combinant par exemple le tri et les recherches FULLTEXT pour récupérer les lignes par ordre de pertinence ou pourquoi pas sur des résultats de calcul.

Ca peut sembler inutile à première vue lorsqu’on utilise MySQL au travers d’API d’autres langages (PHP, Perl, C# etc.). Et pourtant ça peut vous être très utile pour économiser des requêtes, du temps à programmer ces boucles et puis surtout, par flemme.

Oui, la flemme est pour moi la qualité numéro un du développeur car le flemmard a pour but d’arriver à ses fins en un minimum d’efforts.

Déclaration de variables

On peut déclarer une variable de deux façons dans MySQL.
La première méthode consiste à utiliser l’opérateur SET.

SET @pierre = 3, @feuille = 3 + 2, @ciseau = @pierre % @feuille ;

On peut également consister une variable à partir d’une requête.

SELECT @nb_total := COUNT(*) FROM `ma_table` ;

Note : dans ce cas là, on préfixe l’opérateur = de : (deux points).

Utilisation simple des variables

L’utilisation première qui peut en être faite c’est d’assainir vos requêtes SQL en évitant au maximum l’apparition de variables issues d’autres langages.
Avant :

SELECT * FROM `ma_table` WHERE colonne1 = {$variable1}, colonne2 = '{$variable2}' LIMIT 1;

Après :

SET @variable1 = {$variable1}, @variable2 = '{$variable2}';
SELECT * FROM `ma_table` WHERE colonne1 = @variable1, colonne2 = @variable2 LIMIT 1;

Comme les variables sont effectives pour la connexion courante, une variable MySQL peut être réutilisée à tout moment. De quoi décomplexifier certains scripts pas forcément bien structurés.

Utilisation complexe des variables

Les variables peuvent également être modifiées à même la requête. C’est à dire qu’à chaque itération effectuée par MySQL, le moteur va réévaluer le contenu de la variable. J’ai notamment eu besoin de ça pour ajouter de nouveaux éléments à la suite d’autres tout en renumérotant leur ordre. Je souhaitais éviter une boucle récursive en PHP qui aurait occasionné de multiples requêtes.

Je dispose d’une table (item_liste) avec plusieurs éléments, une clé primaire sur deux champs (item_id et item_cat) ainsi qu’un autre champ indexé permettant de les trier dans un ordre donné (item_ordre). Le but : prendre des éléments de la catégorie 1 pour les mettre à la suite de la catégorie 2.

Voici en gros ce que ça donne au final :

SELECT @ordre := IFNULL(MAX(item_ordre), 0) FROM `item_liste` WHERE item_cat = 2 ;
UPDATE `item_liste` SET item_ordre = @ordre := @ordre+1, item_cat = 2 WHERE item_cat = 1 ;

1. On compte la borne supérieure de la catégorie 2. Pourquoi un IFNULL ? Parce MAX() retournera NULL si un des item_ordre en contient un. C’est une sécurité ;
2. On met à jour les éléments de la catégorie 1 avec leur nouvel ordonnancement et leur nouvelle catégorie.

Alors pourquoi ça fonctionne ? La commande UPDATE balaie les lignes une par une et du coup, met à jour la variable @ordre à chaque ligne. Nous retrouvons ainsi l’effet désiré : incrémenter chaque ligne déplacée dans la nouvelle catégorie.

Il existe des utilisations plus compliquées que celles-là mais je pense que c’est un bon départ pour se faire une idée de ce qui est faisable par ce biais là. L’imagination et les besoins feront le reste

Je vous l’annonce, depuis janvier 2007 je suis boulimique. Boulimique mais d’informations, de connaissances et de savoir. S’il y a bien un univers qui ne pardonne pas à ceux qui se contentent des acquis, c’est bien celui d’Internet. Donc en plus des 300 brèves quotidiennes que je lis, je viens de passer commande de trois livres :

• Ppk on Javascript (New Riders Publishing, en anglais)
• CSS Mastery (Friends of ED, en anglais)
• Subversion : Pratique des projets collaboratifs avec SVN (Eyrolles, en français)

Au début de l’année j’avais jeté mon dévolu sur trois autres références pour voir où j’en étais, ce que j’avais encore à apprendre (beaucoup) et ce qui pouvait me faciliter la vie :

• PHP 5 avancé (Eyrolles) que j’avais trouvé moyen car davantage débutant qu’avancé
• Maîtriser MySQL 5 (O’Reilly) que je n’ai pas encore terminé mais intéressant bien que pas assez complet à mon goût au niveau des fonctions utiles
• Gestion de projets avec Subversion (O’Reilly) que je n’ai pas non plus terminé, très technique et instructif mais il me manquait les bases pour bien comprendre comment bien utiliser Subversion

D’ailleurs peut-être que ça en intéresse certains d’avoir une critique de plus sur ces ouvrages. Faites signe (ou canard)

C’est finalement en relisant un article fort intéressant concernant l’installation d’un dépôt Subversion sous Ubuntu que j’ai décidé de passer à l’acte.

Subversion : Pratique des projets collaboratifs avec SVN

Subversion est un formidable outil de gestion et d’archivage de fichiers très utilisé dans les projets informatiques. Il est performant, efficace et permet le travail simultané de plusieurs personnes sur un même projet. Je souhaitais coupler cet outil avec l’interface en ligne TRAC pour gérer des tickets d’incidents ainsi que les feuilles de route. Pour ne plus jamais oublier un bug à corriger ou une fonctionnalité à rajouter.

Ppk on Javascript

J’ai découvert le site de l’auteur bien avant qu’il écrive son livre et je le trouvais déjà fort bien renseigné concernant les différences de comportement entre les différents navigateurs Web concernant Javascript. Egalement de bonnes explications à propos de la gestion des objets, des évènements et les manipulations du DOM. Ce livre très orienté sur la pratique et l’expérience de son auteur (le plus important à mes yeux) aborde les manipulations de CSS, les incompatibilités des navigateurs, bien déboguer son code ainsi que des cas pratiques avec des exemples concrets. Pour que Thomas = { 'taille' : 183, 'feignant' : true } ne soit plus un mystère pour vous

CSS Mastery

La même chose que Ppk on Javascript mais avec des CSS ! Pour bien comprendre les différents bugs des navigateurs, les histoires de DOCTYPE et de mode navigateur, les bonnes pratiques pour maintenir son code CSS, les hacks, les filtres et tout ce qui est recommandé ou pas. Bref ça me paraît être un bon choix.

Rendez-vous dans quelques temps : on verra bien si ça me servira

Sélection optimisée avec IN()

IN() devrait être utilisé dès lors que l’on a plusieurs critères sur un même colonne. L’écriture suivante ne devrait pas apparaitre dans votre code :

SELECT * FROM `ma_table` WHERE id = 3 OR id = 5;

A la place, il devrait y avoir ceci :

SELECT * FROM `ma_table` WHERE id IN (3, 5);

C’est une habitude à prendre car elle permettra d’automatiser bien des choses. Imaginez qu’on ne fasse plus cette sélection « en dur » mais à partir d’un tableau PHP. Trois façons d’écrire la requête, vous verrez vite laquelle sera la plus pratique à réutiliser :

$tableau = array(3, 5);
/* Méthode 1 : vite-fait mal fait */
$separateur = '';
$sql = "SELECT * FROM `ma_table` WHERE ";
foreach( $tableau as $id )
{
	$sql .= $separateur." id = ".$id;
	$separateur = ' OR ';
}
/* Méthode 2 : utilisation "optimisée" avec des OR dans la requête */
$sql = "SELECT * FROM `ma_table` WHERE id = ".implode(' OR id = ', $tableau);
/* Méthode 3 : passe-partout */
$sql = "SELECT * FROM `ma_table` WHERE id IN (".implode(',', $tableau).")";

Le gros avantage de la dernière méthode c’est le retraitement des données. Il est facile et plus logique d’imploser et d’exploser une chaine composée de séparateurs virgule (ou autre caractère employé aux mêmes fins).

$tableau = array(3, 5);
$tableau = implode(',', $tableau);
/* du code nécessitant $tableau en tant que chaîne */
$tableau = explode(',', $tableau);
/* du code nécessitant $tableau en tant que tableau */

Aggrégats avec GROUP_CONCAT()

Dans les exemples précédents, $tableau était rempli « en dur ». Dans la vraie vie, ça ne se passe pas comme ça : on récupère des identifiants (clés et/ou index) pour valider les sélections. L’exemple basique : on veut mettre à jour une table de configuration avec les ID d’articles présents dans une ou plusieurs catégories.

$tableau = array();
/* Sélection des ID */
$query = mysql_query("SELECT id FROM `ma_table` WHERE cat_id IN ('fromage', 'tortues');");
while( $ligne = mysql_fetch_assoc($query) )
{
	$tableau[] = $ligne['id'];
}
/* On met à jour notre table de configuration */
$tableau = implode(',', $tableau);
mysql_query("REPLACE INTO `table_config` (config_id, config_valeur) ".
	"('cache_articles', '{$tableau}')");

C’est simple, propre et on se dit qu’on a bien bossé. Et pourtant, l’utilisation de la fonction d’agrégation GROUP_CONCAT() de MySQL nous épargnera quelques lignes. On appréciera :

$tableau = array();
/* Sélection des ID */
$query = mysql_query("SELECT GROUP_CONCAT(id) AS cache_articles FROM `ma_table` WHERE cat_id IN ('fromage', 'tortues');");
$tableau = mysql_fetch_assoc($query);
/* On met à jour notre table de configuration */
mysql_query("REPLACE INTO `table_config` (config_id, config_valeur) ".
	"('cache_articles', '{$tableau['cache_articles']}'");

Bref, on a gagné une boucle (le while), des lignes de résultats MySQL (autant de ressources d’économisées) et un traitement PHP en moins (implode). Et devinez quoi ? Le résultat retourné par le GROUP_CONCAT s’intègre très bien dans le … IN().