.net 1998 October/dotnet_50.iso/pc/PC/Redac/doc MySQL 3.23/manuel.doc

Word Document | 2000-08-10 | 2.5 MB | 20,126 lines

|[pic][pic]                                                                                  |
|[pic][pic][pic][pic]                                                                        |
|[pic|[pic]                                                                                 |
|]   |                                                                                      |
|    |[pic]                                                                                 |
|    |[pic]                                                                                 |
|    |1 Informations générales à propos de MySQL                                            |
|    |Ceci est la manuel de référence de MySQL; il correspond à la version 3.23.2-alpha de  |
|    |MySQL.                                                                                |
|    |MySQL est un langage rapide, multi-threaded, multi-utilisateur, c'est aussi un serveur|
|    |de base de données SQL robuste (Structured Query Language).                           |
|    |Pour les plates-formes Unix et OS/2, MySQL est libre; pour les plates-formes Microsoft|
|    |il est nécessaire d'acquitter une licence après un temps d'essai de 30 jours. 3       |
|    |Support et licences MySQL).                                                           |
|    |The MySQL home page fournit les dernières informations concernant MySQL.              |
|    |Pour une description des capacités de MySQL, 1.4 Caractéristiques de MySQL.           |
|    |Pour les instructions d'installation, cf. section G Commentaires sur le portage vers  |
|    |d'autres systèmes d'exploitation.                                                     |
|    |Pour une information sur la mise à jour de la version 3.21, 4.16.2 Mise à jour de a   |
|    |3.21 vers 3.22.                                                                       |
|    |Pour un exemple complet, 8 Exemple MySQL.                                             |
|    |Pour des informations sur SQL et les benchmark, reportez vous au dossier de benchmark.|
|    |Dans les distributions source, il est situé dans le dossier ``bench'' . Dans les      |
|    |distributions compilées, il est situé dans le dossier ``sql-bench''                   |
|    |Pour un historique des caractéristiques et des bogues corrigés, D Historique des      |
|    |versions de MySQL.                                                                    |
|    |Pour une liste des bogues connus et des lacunes de MySQL, E Erreurs connues et manques|
|    |de MySQL.                                                                             |
|    |Pour les prochaines fonctionnalités, F Liste de voeux pour les versions futures de    |
|    |MySQL (la TODO).                                                                      |
|    |Pour la liste de tous les contributeurs à ce produit, C Contributions à MySQL.        |
|    |IMPORTANT:                                                                            |
|    |Envoyer les bugs ou erreurs, questions ou commentaires à la liste de diffusion :      |
|    |[e-mail]. 2.3 Comment rapporter des bugs et des problèmes.               |
|    |Dans les distributions source, le script mysqlbug est rangé dans le dossier           |
|    |``scripts''. Dans les distributions compilées, mysqlbug est rangé dans le dossier     |
|    |``bin''.                                                                              |
|    |Si vous avez des suggestions concernant les ajouts de fonctionnalités ou corrections à|
|    |ce manuel, envoyer les à la liste de diffusion (en anglais)                           |
|    |(@email:{[e-mail]}), avec le sujet suivant : documentation suggestion :  |
|    |[Insert topic here]. 2.1 Les listes de diffusion MySQL                                |
|    |1.1 Qu'est ce que MySQL?                                                              |
|    |MySQL est un véritable serveur de base de données SQL multi-utilisateur et            |
|    |multi-threaded. SQL est le plus populaire langage de base de données dans le monde.   |
|    |MySQL est une configuration client/serveur ce qui consiste en un serveur démon mysqld,|
|    |différents programmes clients et des librairies.                                      |
|    |SQL est un langage standardisé qui rend facile le stockage, la mise à jour et l'accès |
|    |à l'information. Par exemple, vous pouvez utiliser le SQL pour récupérer des          |
|    |informations sur un produit ou stocker des informations client sur un site web. MySQL |
|    |est suffisamment rapide et flexible pour gérer des historiques et des images.         |
|    |Les principaux objectifs de MySQL sont la rapidité, la robustesse et la facilité      |
|    |d'utilisation. MySQL a été originellement développé parce que nous au TcX avions      |
|    |besoin d'un serveur SQL qui puisse gérer des grandes bases de données de manière plus |
|    |rapide que ce que pouvaient offrir les distributeurs de bases de données. Nous        |
|    |utilisons donc MySQL depuis 1996 dans un environnement de plus de 40 bases de données |
|    |contenant 10,000 tables, dont plus de 500 contiennent plus de 7 millions              |
|    |d'enregistrements. C'est environ 100 giga octets de données critiques.                |
|    |La base sur laquelle MySQL est construite est un ensemble de routines qui ont été     |
|    |largement éprouvées pendant des années dans un environnement de production exigeant.  |
|    |Même si MySQL est encore en développement, il propose déjà un ensemble de             |
|    |fonctionnalités riches et extrêmement utiles.                                         |
|    |La prononciation classique de MySQL est ``Maille Ess Ku Ell''                         |
|    |1.2 A propos de ce manuel                                                             |
|    |Ce manuel est actuellement disponible en Texinfo, texte plein, Info, HTML, PostScript |
|    |and PDF versions. A cause de leur taille, les versions en PostScript et PDF ne sont   |
|    |pas inclues dans la distribution principale de MySQL, mais sont disponibles sur       |
|    |http://www.mysql.com.                                                                 |
|    |Le document initial est le fichier Texinfo. La version HTML a été générée             |
|    |automatiquement avec une version modifiée de texi2html. Les versions plain text et    |
|    |Info ont été produites avec makeinfo. La version Postscript version a été produite en |
|    |utilisant texi2dvi et dvips. La version PDF a été produite avec l'utilitaire          |
|    |Ghostscript ps2pdf.                                                                   |
|    |La version américaine de ce manuel a été écrite et mise à jour par David Axmark,      |
|    |Michael (Monty) Widenius, Paul DuBois and Kim Aldale. Pour les autres contributeurs,  |
|    |cf. section C Contributions à MySQL.                                                  |
|    |1.2.1 Conventions utilisées dans ce manuel                                            |
|    |Ce manuel utilise certaines conventions typographiques :                              |
|    |constant                                                                              |
|    |La police à empattement constant est utilisée pour les noms de commandes et les       |
|    |options; les déclarations en SQL; les noms de base de données, tables et colonnes; le |
|    |code en C et Perl; et les variables d'environnement. Exemple: ``Pour obtenir une aide |
|    |succinte, utilisez l'option --help de mysqladmin.''                                   |
|    |``filename''                                                                          |
|    |La police à empattement constant avec des guillemets est utilisée pour les noms de    |
|    |fichiers et les arborescences. Exemple: ``La distribution est installée dans le       |
|    |dossier ``/usr/local/''.''                                                            |
|    |``c''                                                                                 |
|    |La police à empattement constant avec des guillemets est aussi utilisée pour indiquer |
|    |une suite de caractères. Exemple: ``Pour indiquer un caractère joker, utilisez le     |
|    |caractère ``%''.''                                                                    |
|    |italic                                                                                |
|    |La police italic est utilisée pour mettre en relief certains termes, Comme ceci.      |
|    |boldface                                                                              |
|    |La police Gras pour un accès à des noms privilégiés (e.g., ``Ne distribuez pas le     |
|    |droit de process à la légère'') et souligner des termes spécialement importants.      |
|    |Lorsque les commandes sont décrites et doivent être exécutées par un programme        |
|    |spécifique, le programme est indiquée par le prompt avec la commande. Par exemple,    |
|    |shell> indique que la commande doit être exécutée à partir du login shell, et mysql>  |
|    |indique que la commande doit être exécutée à partir client mysql.                     |
|    |                                                                                      |
|    |shell> Tapez une commande shell ici                                                   |
|    |                                                                                      |
|    |mysql> Tapez une commande mysql ici                                                   |
|    |Les commandes Shell décrites utilisent la syntaxe shell Bourne. Si vous utilisez un   |
|    |shell csh, vous devez formuler vos commandes un peu différemment.                     |
|    |Par exemple, la séquence de mise à jour d'une variable d'environnement et d'exécution |
|    |d'une commande se présente comme suit dans la syntaxe Bourne:                         |
|    |                                                                                      |
|    |shell> VARNAME=value some_command                                                     |
|    |pour csh:                                                                             |
|    |shell> setenv VARNAME value                                                           |
|    |                                                                                      |
|    |shell> some_command                                                                   |
|    |Les noms de base de données, tables et colonnes sont souvent utilisés dans des        |
|    |commandes. Pour indiquer ces utilisations le manuel utilise la convention suivante,   |
|    |nom_base_de_donnees, nom_table et nom_colonne. Par exemple, vous pourrez voir des     |
|    |déclarations comme les suivantes:                                                     |
|    |                                                                                      |
|    |mysql> SELECT nom_colonne FROM nom_base_de_donnees.nom_table;                         |
|    |Cela signifie que si vous devez utiliser une déclaration similaire, vos utiliserez vos|
|    |propres noms de base de données, de tables et de colonnes, peut-être comme ceci :     |
|    |                                                                                      |
|    |mysql> SELECT nom_auteur FROM biblio_db.liste_auteur;                                 |
|    |Les déclarations SQL peuvent être écrites en majuscules ou minuscules. Lorsque ce     |
|    |manuel montre une expression SQL, les majuscules sont utilisées pour les mots clefs en|
|    |cours de discussion et les minuscules pour le reste de l'expression. Donc vous pourrez|
|    |voir ce qui suit pour la déclaration du SELECT:                                       |
|    |                                                                                      |
|    |mysql> SELECT count(*) FROM nom_table;                                                |
|    |D'autre part, si il s'agit de la fonction COUNT(), l'expression sera écrite comme     |
|    |suit:                                                                                 |
|    |                                                                                      |
|    |mysql> select COUNT(*) from nom_table;                                                |
|    |Dans le cas où aucun mot clef n'est à souligner, l'expression est en majuscule.       |
|    |Dans la description de la syntaxe d'une expression, les crochets (``['' et ``]'') sont|
|    |utilisés pour indiquer les options:                                                   |
|    |                                                                                      |
|    |DROP TABLE [IF EXISTS] nom_table                                                      |
|    |Lorsque les éléments syntaxiques consistent en un certain nombres d'alternatives, les |
|    |alternatives sont séparés par des barres verticales (``|''). Quand un membre d'un     |
|    |ensemble de possibilités peut être choisit, les possibilités sont listées à           |
|    |l'intérieure de crochets. Quand un membre doit être choisit, les possibilités sont    |
|    |listées à l'intérieure de (``{'' and ``''}):                                          |
|    |                                                                                      |
|    |TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)                                 |
|    |                                                                                      |
|    |{DESCRIBE | DESC} nom_table {nom_colonne | wild}                                      |
|    |1.3 Historique de MySQL                                                               |
|    |Nous avions l'intention d'utiliser mSQL pour se connecter à nos tables fondées sur nos|
|    |routines (ISAM). Après plusieurs tests, nous sommes venus à la conclusion que mSQL    |
|    |n'était pas assez rapide, ni flexible pour nos besoins. La résultat a été le codage   |
|    |d'une nouvelle interface SQL pour notre base ave la plupart des interface API de mSQL.|
|    |Ces API ont été choisis pour faciliter le portage sur des codes tiers.                |
|    |La dérivation du nom MySQL n'est pas parfaitement claire. Notre arborescence et un    |
|    |certain nombre de nos librairies et outils commencaient par le préfixe "My" depuis des|
|    |années. Même si la soeur de Monty (il y a quelques années) était surnommée My. A part |
|    |les deux anecdotes le nom de MySQL est encore un mystère, pour nous aussi.            |
|    |1.4 Caractéristiques de MySQL                                                         |
|    |La liste suivante décrit quelques caractéristiques importantes de MySQL:              |
|    |Complètement multi-threaded en utilisant les threads du noyau. Cela signifie qu'il    |
|    |peut utiliser plusieurs CPU.                                                          |
|    |C, C++, Eiffel, Java, Perl, PHP, Python et TCL APIs. 20 API MySQL.                    |
|    |Fonctionne sur différentes plates-formes. 4.2 Systèmes d'exploitation supportés par   |
|    |MySQL.                                                                                |
|    |Plusieurs types de colonnes: entier signé/non-signé 1, 2, 3, 4et 8 bytes long, FLOAT, |
|    |DOUBLE, CHAR, VARCHAR, TEXT, BLOB, DATE, TIME, DATETIME, TIMESTAMP, YEAR, SET et ENUM |
|    |types. 7.2 Types de colonnes.                                                         |
|    |Jointures ultra rapides, gr?ce à un optimiseur de jointures à une passe.              |
|    |Les requêtes SELECT et WHERE supportent tous les opérateurs et fonctions. Exemple:    |
|    |                                                                                      |
|    |mysql> SELECT CONCAT(first_name, " ", last_name) FROM nom_table                       |
|    |WHERE income/dependents > 10000 AND age > 30;                                         |
|    |Les fonctions SQL sont implémentées à travers des classes de librairies extrêmement   |
|    |optimisées et devraient fonctionner aussi vite qu'elles peuvent! En général il n'y a  |
|    |plus d'allocation mémoire après une requête d'initialisation.                         |
|    |Support pour les clauses des instructions SQL GROUP BY et ORDER BY . Support pour le  |
|    |groupe d'instructions (COUNT(), COUNT(DISTINCT), AVG(), STD(), SUM(), MAX() et MIN()).|
|    |                                                                                      |
|    |Support pour LEFT OUTER JOIN avec la syntaxe ANSI SQL et ODBC.                        |
|    |Le mélange des tables de différentes bases de données est supporté dans une même      |
|    |requête (après la version 3.22).                                                      |
|    |Système flexible et sécurisé de droits et de mots de passe, et qui autorise une       |
|    |vérification faites sur l'hôte. Les mots de passe sont sécurisés depuis que la gestion|
|    |des mots de passe est crypté entre le client et le serveur.                           |
|    |ODBC (Open-DataBase-Connectivity) pour Windows95 (avec source). Toutes les fonctions  |
|    |ODBC 2.5 et d'autres. Vous pouvez, par exemple, utiliser Access pour vous connecter au|
|    |serveur MySQL. 16 MySQL et ODBC                                                       |
|    |Tables rapides à B-tree avec compression des index.                                   |
|    |16 index par tables sont autorisés. Chaque index consiste en 1 et 15 colonnes ou      |
|    |parties de colonnes. La longueur maximale d'un index est de 256 bytes (ceci peut être |
|    |modifié lors de la compilation MySQL). Un index devrait utiliser un préfixe CHAR ou   |
|    |VARCHAR .                                                                             |
|    |Enregistrements de longueur fixe ou variable.                                         |
|    |Les Tables de hashage en mémoire, qui sont utilisées comme des tables temporaires.    |
|    |Gestion de grandes bases de données. Nous utilisons MySQL avec des bases de 50,000,000|
|    |enregistrements.                                                                      |
|    |Toutes les colonnes ont des valeurs par défaut. Vous pouvez utiliser INSERT pour      |
|    |insérer un ensemble de colonnes; les colonnes qui n'ont de valeurs explicites sont    |
|    |initialisées à leur valeur par défaut.                                                |
|    |Utilise GNU Automake, Autoconf et libtool pour la portabilité.                        |
|    |Ecrit en C et C++. Testé avec un nombre conséquent de compilateurs différents.        |
|    |Système efficace d'allocation mémoire thread-based.                                   |
|    |Pas de perte de mémoire. Testé avec un détecteur de perte de mémoire commercial       |
|    |(purify).                                                                             |
|    |Inclus isamchk, un utilitaire rapide pour le contrôle, l'optimisation et la réparation|
|    |des tables. 13 Maintenance d'un serveur MySQL                                         |
|    |Support de l' ISO-8859-1 Latin1. Par exemple, les caractères scandinaves              |
|    |@ringaccent{a}, @"a and @"o sont autorisés dans le nom des tables et des colonnes.    |
|    |Toutes les données sont sauvegardées sous le format ISO-8859-1 Latin1. Les            |
|    |comparaisons de colonnes en chaînes de caractères normales sont "insensible à la      |
|    |casse".                                                                               |
|    |Le tri est cohérent avec la norme ISO-8859-1 Latin1. Il est possible de le changer    |
|    |dans le source en ajoutant un nouveau tableau de tri. Pour voir un exemple de tri     |
|    |avancé, regardez le code Tchèque. MySQL supporte différentes polices qui peuvent être |
|    |spécifiées à la compilation.                                                          |
|    |Alias sur les tables et colonnes comme dans le standard SQL92.                        |
|    |DELETE, INSERT, REPLACE et UPDATE retournent le nombre de lignes traitées.            |
|    |Les noms de fonction restent disponibles pour les tables et les colonnes. Par exemple,|
|    |ABS reste un nom de colonne valide. L'unique restriction est que lors de l'appel d'une|
|    |fonction, les espaces entre le nom de la fonction et les parenthèses '(' qui suivent  |
|    |ne sont pas autorisées. 7.30 Mots reservés par MySQL                                  |
|    |Tous les programmes de MySQL dispose d'une aide en ligne, accessible gr?ce à l'option |
|    |--help ou -?.                                                                         |
|    |Le serveur peut fournir au client les messages d'erreurs en plusieurs langues. 9.1    |
|    |Quels sont les langues supportés par MySQL?.                                          |
|    |Les clients se connectent au serveur MySQL en utilisant les connexions TCP/IP, les    |
|    |sockets Unix ou les pipes nommés sous NT.                                             |
|    |La commande spécifique à MySQL SHOW peut être utilisée pour avoir des informations    |
|    |concernant les bases de données, les tables et les index. La commande EXPLAIN peut    |
|    |être utilisée pour déterminer comment l'optimiseur résout la requête.                 |
|    |1.5 Est ce que MySQL est stable?                                                      |
|    |Cette section répond aux questions "Qu'elle est la stabilité de MySQL?'' et, ``Puis-je|
|    |faire confiance à MySQL sur ce projet?''. Nous allons essayer de clarifier quelques   |
|    |problèmes et répondre aux questions les plus importantes qui concernent une majorité  |
|    |de personnes. Cette section rassemble les informations récoltées dans la liste de     |
|    |diffusion (qui est très active dans l'identification des bogues).                     |
|    |A TcX, MySQL fonctionne depuis mi-1996 sans aucun problème. Lorsque MySQL a été       |
|    |diffusé auprès du grand public, un certain nombre de codes n'avaient pas été testés et|
|    |ils ont été vite identifiés par les nouveaux utilisateurs qui ont utilisé les requêtes|
|    |d'une manière différente de la notre. Chaque nouvelle release a moins de problèmes de |
|    |portabilité que la précédente (même si à chaque fois de nouvelles fonctionnalités sont|
|    |identifiées), et nous espérons bientôt qu'une prochaine version sera labellisée       |
|    |"Stable".                                                                             |
|    |Chaque release de MySQL est utilisable et il n'y a de problèmes uniquement lorsque les|
|    |utilisateurs commencent à utiliser les "zones d'ombres". Naturellement, il est        |
|    |difficile de connaître le contenu de ces zones d'ombres; cette section a pour objectif|
|    |d'identifier les zones connues. La description concerne la version 3.22.x de MySQL.   |
|    |Tous les bogues connus sont corrigés dans la dernière version, à l'exception de la    |
|    |liste des bogues répertoriés dans la section des erreurs. Cf. section E Erreurs       |
|    |connues et manques de MySQL.                                                          |
|    |MySQL est décomposé en plusieurs couches et différents modules indépendants. Les      |
|    |modules sont listés ci-dessous avec leur état de stabilité :                          |
|    |Le gestionnaire de tables ISAM -- Stable                                              |
|    |Il gère le stockage et la lecture de toutes les données. Dans toutes les releases de  |
|    |MySQL, un seul bogue a été reporté. La seule façon connue d'avoir une table corrompue |
|    |est de "tuer" le serveur au milieu de la mise à jour. Et même un tel scénario ne      |
|    |détruira probablement pas toutes les données sans qu'il soit possible de les          |
|    |récupérer, car toutes les données sont vidées de la mémoire, entre chaque requête. Il |
|    |n'y a jamais eu de bogues liés à la destruction de données.                           |
|    |L'analyseur syntaxique et l'analyseur lexical -- Stable                               |
|    |Il n'y a pas un seul bogue d'identifié depuis longtemps dans ce module.               |
|    |Le code du client C -- Stable                                                         |
|    |Pas de problèmes connus. Dans la version précédente 3.20, il y avait quelques limites |
|    |dans la taille du buffer d'envoi/réception. Depuis de la 3.21.x, la taille du buffer  |
|    |est maintenant dynamique et initialisé par défaut à 24M.                              |
|    |Programmes clients standards -- Stable                                                |
|    |Cela inclus mysql, mysqladmin et mysqlshow, mysqldump, et mysqlimport.                |
|    |Basic SQL -- Stable                                                                   |
|    |Système de fonction basic SQL, classes de chaînes de caractères et gestion dynamique  |
|    |de la mémoire. Pas de bogues identifiés.                                              |
|    |Optimiseur de requête -- Gamma                                                        |
|    |Optimiseur d'intervalle -- Stable                                                     |
|    |Optimiseur de jointure -- Stable                                                      |
|    |Verrouillage -- Gamma                                                                 |
|    |Cela est très dépendant du système. Sur certains systèmes il y a de gros problèmes en |
|    |utilisant le verrouillage standard de l'OS (fcntl()). Dans ces cas là, vous devriez   |
|    |faire fonctionner le démon MySQL avec l'option --skip-locking. Les problèmes sont     |
|    |connus, sur quelques systèmes Linux et sur SunOS lorsque le gestionnaire de fichiers  |
|    |est monté sur NFS.                                                                    |
|    |Linux threads -- Gamma                                                                |
|    |Le seul problème identifié concerne l'appel de la fonction fcntl(), qui est résolu en |
|    |utilisant l'option --skip-locking de mysqld. Quelques personnes ont reporté des       |
|    |problèmes avec la version release 0.5.                                                |
|    |Solaris 2.5+ pthreads -- Stable                                                       |
|    |Nous l'utilisons pour nos systèmes en production.                                     |
|    |MIT-pthreads (autres systèmes) -- Gamma                                               |
|    |Il y a pas de bogues identifiés depuis la 3.20.15 et la 3.20.16. sur quelques         |
|    |systèmes, il y a un disfonctionnement . Quelques opérations sont assez lentes (un     |
|    |arrêt de 1/20 second est effectué entre chaque requête). Bien sur, MIT-pthreads peut  |
|    |ralentir un peu l'ensemble, mais les commandes SELECT qui utilisent des index sont    |
|    |faites en un laps de temps tellement court, que le verrouillage et l'échange de thread|
|    |n'est pas nécessaire.                                                                 |
|    |Autres implémentations -- Alpha - Beta                                                |
|    |Le portage sur d'autres systèmes restent assez nouveau et ont peut-être des bugs,     |
|    |probablement dans le serveur MySQL, et plus certainement dans l'implémentation des    |
|    |threads.                                                                              |
|    |LOAD DATA ..., INSERT ... SELECT -- Stable                                            |
|    |Quelques personnes ont cru identifier des bogues dans ce module, c'était lié à une    |
|    |méprise. Vérifier la documentation sur le sujet!                                      |
|    |ALTER TABLE -- Gamma                                                                  |
|    |Changements mineures dans la 3.22.12.                                                 |
|    |DBD -- Gamma                                                                          |
|    |Maintenant maintenu par Jochen Wiedmann                                               |
|    |mysqlaccess -- Gamma                                                                  |
|    |Ecrit et maintenu par Yves Carlier                                                    |
|    |GRANT -- Beta                                                                         |
|    |Gros changement dans la MySQL 3.22.12.                                                |
|    |MyODBC (utilise ODBC SDK 2.5) -- Beta                                                 |
|    |Il fonctionne normalement avec la plupart des programmes.                             |
|    |TcX fournit un support payant par email, cependant la mailing liste MySQL répond à la |
|    |plupart des questions. Les bogues sont en général corrigés par des patchs; pour les   |
|    |bogues plus importants, il y a de nouvelles versions.                                 |
|    |1.6 Compatibilité an 2000                                                             |
|    |MySQL lui-même n'a pas de problémes avec la compatibilité An 2000 (Y2K):              |
|    |MySQL utilise les fonctions de gestion du temps d'Unix et n'a pas de problèmes        |
|    |jusqu'en 2069; toutes les années sur 2-digit sont comprises entre 1970 et 2069, cela  |
|    |qui signifie que si vous stocker 01 dans une colonne année, MySQL le traite comme     |
|    |2001.                                                                                 |
|    |Toutes les fonctions de date de MySQL sont stockées dans un fichier unique            |
|    |``sql/time.cc'' et codées pour être compatible An 2000.                               |
|    |Dans la version 3.22 de MySQL et les versions ultérieures, le nouveau type de colonne |
|    |Année peut stocker des années entre 0 et 1901 jusqu'à 2155 sur 1 byte et éditer sur 2 |
|    |ou 4 digits.                                                                          |
|    |Vous pouvez avoir des problèmes avec des applications qui utilisent MySQL mais non    |
|    |compatible An 2000.                                                                   |
|    |Malheureusement ces problèmes sont difficilement corrigibles lorsque ces applications |
|    |sont écrites par différents programmeurs et que chacun utilise ses propres conventions|
|    |pour gérer les dates.                                                                 |
|    |Vous trouverez ci-après une démonstration simple qui illustre le fait que MySQL n'a   |
|    |aucun problème avec les dates jusqu'en 2030!                                          |
|    |                                                                                      |
|    |mysql> DROP TABLE IF EXISTS y2k;                                                      |
|    |                                                                                      |
|    |mysql> CREATE TABLE y2k (date date, date_time datetime, time_stamp timestamp);        |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("1998-12-31","1998-12-31 23:59:59",19981231235959);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("1999-01-01","1999-01-01 00:00:00",19990101000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("1999-09-09","1999-09-09 23:59:59",19990909235959);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2000-01-01","2000-01-01 00:00:00",20000101000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2000-02-28","2000-02-28 00:00:00",20000228000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2000-02-29","2000-02-29 00:00:00",20000229000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2000-03-01","2000-03-01 00:00:00",20000301000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2000-12-31","2000-12-31 23:59:59",20001231235959);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2001-01-01","2001-01-01 00:00:00",20010101000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2004-12-31","2004-12-31 23:59:59",20041231235959);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2005-01-01","2005-01-01 00:00:00",20050101000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2030-01-01","2030-01-01 00:00:00",20300101000000);    |
|    |                                                                                      |
|    |mysql> INSERT INTO y2k VALUES ("2050-01-01","2050-01-01 00:00:00",20500101000000);    |
|    |                                                                                      |
|    |mysql> SELECT * FROM y2k;                                                             |
|    |                                                                                      |
|    |                                                                                      |
|    |+------------+---------------------+----------------+                                 |
|    || date       | date_time           | time_stamp     |                                 |
|    |+------------+---------------------+----------------+                                 |
|    || 1998-12-31 | 1998-12-31 23:59:59 | 19981231235959 |                                 |
|    || 1999-01-01 | 1999-01-01 00:00:00 | 19990101000000 |                                 |
|    || 1999-09-09 | 1999-09-09 23:59:59 | 19990909235959 |                                 |
|    || 2000-01-01 | 2000-01-01 00:00:00 | 20000101000000 |                                 |
|    || 2000-02-28 | 2000-02-28 00:00:00 | 20000228000000 |                                 |
|    || 2000-02-29 | 2000-02-29 00:00:00 | 20000229000000 |                                 |
|    || 2000-03-01 | 2000-03-01 00:00:00 | 20000301000000 |                                 |
|    || 2000-12-31 | 2000-12-31 23:59:59 | 20001231235959 |                                 |
|    || 2001-01-01 | 2001-01-01 00:00:00 | 20010101000000 |                                 |
|    || 2004-12-31 | 2004-12-31 23:59:59 | 20041231235959 |                                 |
|    || 2005-01-01 | 2005-01-01 00:00:00 | 20050101000000 |                                 |
|    || 2030-01-01 | 2030-01-01 00:00:00 | 20300101000000 |                                 |
|    || 2050-01-01 | 2050-01-01 00:00:00 | 00000000000000 |                                 |
|    |+------------+---------------------+----------------+                                 |
|    |13 rows in set (0.00 sec)                                                             |
|    |                                                                                      |
|    |mysql> DROP TABLE y2k;                                                                |
|    |Cela montre que le type DATE et DATETIME sont compatibles, alors que le type          |
|    |TIMESTAMP, qui est utilisé pour stocker la date courante, est limitée au 2030-01-01.  |
|    |TIMESTAMP est compris entre 1970 et 2030 sur les machines 32-bits.                    |
|    |Même si MySQL est compatible An 2000, il est de votre responsabilité de fournir une   |
|    |entrée correcte. 7.2.6.1 Bug de l'an 2000 et données de types date pour les règles    |
|    |appliquées par MySQL pour la gestion des entrées ambiguës de données (Donnée contenant|
|    |des valeurs sur 2-digit).                                                             |
|    |1.7 Informations sur le SQL                                                           |
|    |Ces livres ont été recommandés par plusieurs personnes sur la liste de diffusion MySQL|
|    |:                                                                                     |
|    |                                                                                      |
|    |Judith S. Bowman, Sandra L. Emerson et Marcy Darnovsky                                |
|    |                                                                                      |
|    |The Practical SQL Handbook: Using Structured Query Language                           |
|    |                                                                                      |
|    |Second Edition                                                                        |
|    |                                                                                      |
|    |Addison-Wesley                                                                        |
|    |                                                                                      |
|    |ISBN 0-201-62623-3                                                                    |
|    |                                                                                      |
|    |http://www.awl.com                                                                    |
|    |Celui-ci aussi a eu quelques recommandations sur la liste de diffusion :              |
|    |                                                                                      |
|    |Martin Gruber                                                                         |
|    |                                                                                      |
|    |Understanding SQL                                                                     |
|    |                                                                                      |
|    |ISBN 0-89588-644-8                                                                    |
|    |                                                                                      |
|    |Publisher Sybex 510 523 8233                                                          |
|    |                                                                                      |
|    |Alameda, CA USA                                                                       |
|    |Un tutorial SQL est disponible sur                                                    |
|    |http://www.geocities.com/ResearchTriangle/Node/9672/sqltut.html                       |
|    |SQL in 21 Tagen (Livre en Allemand ):                                                 |
|    |http://www.mut.de/leseecke/buecher/sql/inhalt.htm                                     |
|    |1.8 Liens utiles                                                                      |
|    |1.8.1 Outils de développement WEB qui supportent MySQL.                               |
|    |http://www.php.net/                                                                   |
|    |http://xsp.lentus.se/                                                                 |
|    |http://www.voicenet.com/~zellert/tjFM                                                 |
|    |http://www.wernhart.priv.at/php/                                                      |
|    |http://www.dbwww.com/                                                                 |
|    |http://www.daa.com.au/~james/www-sql/                                                 |
|    |http://www.minivend.com/minivend/                                                     |
|    |http://www.heitml.com/                                                                |
|    |http://www.metahtml.com/                                                              |
|    |http://www.binevolve.com/                                                             |
|    |http://hawkeye.net/                                                                   |
|    |http://www.fastflow.com/                                                              |
|    |http://www.wdbi.net/                                                                  |
|    |http://www.webgroove.com/                                                             |
|    |http://www.ihtml.com/                                                                 |
|    |ftp://ftp.igc.org/pub/myodbc/README                                                   |
|    |http://calistra.com/MySQL/                                                            |
|    |http://www.webmerger.com Cet outil CGI interprète des fichiers, et génère des         |
|    |affichages dynamiques, basé sur un ensemble simple de balises. Il est fonctionne déjà |
|    |avec MySQL et PostgreSQL via ODBC.                                                    |
|    |1.8.2 Serveurs Web avec des outils MySQL.                                             |
|    |http://bourbon.netvision.net.il/mysql/mod_auth_mysql/                                 |
|    |http://www.roxen.com/                                                                 |
|    |1.8.3 Exemples et sources                                                             |
|    |http://www.little6.com/about/linux/ Un site d'emploi en ligne, construit MySQL, PHP3  |
|    |et Linux.                                                                             |
|    |http://www.delec.com/is/products/prep/examples/BookShelf/index.html Un outil qui rend |
|    |très simple la mise la création de documentation automatique. Ils ont utilisé MySQL   |
|    |comme un exemple.                                                                     |
|    |http://shredder.elen.utah.edu/steve.html Utilise MySQL et webmerger. Il y a une base  |
|    |des employés, et une base des plaques d'immatriculation. (plus de 1.2 million). Le    |
|    |champs des immatriculation est indexé, et les recherches sont instantanées.           |
|    |http://www.worldrecords.com Un moteur de recherche pour la musique, fait avec MySQL et|
|    |PHP.                                                                                  |
|    |http://webdev.berber.co.il/                                                           |
|    |http://www.webtechniques.com/features/1998/01/note/note.shtml                         |
|    |http://modems.rosenet.net/mysql/                                                      |
|    |http://www.odbsoft.com/cook/sources.htm                                               |
|    |http://www.gusnet.cx/proj/telsql/.                                                    |
|    |http://www.productivity.org/projects/mysql/                                           |
|    |http://www.iserver.com/support/contrib/perl5/modules.html                             |
|    |http://tecfa.unige.ch/guides/java/staf2x/ex/jdbc/coffee-break                         |
|    |http://www.spade.com/linux/howto/PostgreSQL-HOWTO-41.html                             |
|    |http://www.ooc.com/                                                                   |
|    |http://www.pbc.ottawa.on.ca/                                                          |
|    |http://keilor.cs.umass.edu/pluribus/ Pluribus, is a free search engine that learns to |
|    |improve the quality of its results over time. Pluribus works by recording which pages |
|    |a user prefers among those returned for a query. A user votes for a page by selecting |
|    |it; Pluribus then uses that knowledge to improve the quality of the results when      |
|    |someone else submits the same (or similar) query. Uses PHP and MySQL.                 |
|    |http://www.stopbit.com/ A technology news site using MySQL and PHP                    |
|    |http://www.jokes2000.com/scripts/                                                     |
|    |http://www.hotwired.com/webmonkey/backend/tutorials/tutorial1.html                    |
|    |http://www.geocities.com/CapeCanaveral/2064/mysql.html                                |
|    |http://futurerealm.com/forum/futureforum.cgi                                          |
|    |http://www.linuxsupportline.com/~kalendar/ KDE based calendar manager The calendar    |
|    |manager has both single user (file based) and multi user (MySQL database) support.    |
|    |http://tim.desert.net/~tim/imger/                                                     |
|    |http://www.penguinservices.com/scripts                                                |
|    |1.8.4 Liens ODBC.                                                                     |
|    |http://www.openlinksw.com/iodbc/                                                      |
|    |http://users.ids.net/~bjepson/freeODBC/                                               |
|    |1.8.5 Liens API.                                                                      |
|    |http://www.jppp.com Partially implemented TDataset-compatible components for MySQL.   |
|    |http://www.riverstyx.net/qpopmysql/ A patch to allow POP3 authentication from a MySQL |
|    |database. There's also a link to someone who wrote a patch for Procmail to allow any  |
|    |MTA to deliver to users in a MySQL database.                                          |
|    |http://www.pbc.ottawa.on.ca                                                           |
|    |http://www.lilback.com/macsql/                                                        |
|    |1.8.6 Clients et applications.                                                        |
|    |http://www.urbanresearch.com/software/utils/urbsql/index.html                         |
|    |http://www.etu.info.unicaen.fr/~fbilhaut/kmysql/                                      |
|    |1.8.7 Autres liens MySQL.                                                             |
|    |http://www.wix.com/mysql-hosting                                                      |
|    |http://www.open.com.au/products.html                                                  |
|    |http://www.stonekeep.com/pts/                                                         |
|    |http://tomato.nvgc.vt.edu/~hroberts/mot                                               |
|    |http://www.seawood.org/msql_bind/                                                     |
|    |http://home.wxs.nl/cgi-bin/planeteers/pgidszoek.cgi                                   |
|    |http://www.cynergi.net/non-secure/exportsql/                                          |
|    |http://SAL.KachinaTech.COM/H/1/MYSQL.html                                             |
|    |http://www.infotech-nj.com/itech/index.shtml                                          |
|    |http://www.pmpcs.com/                                                                 |
|    |http://www.aewa.org                                                                   |
|    |http://abattoir.cc.ndsu.nodak.edu/~nem/mysql/udf/                                     |
|    |http://21ccs.com/~gboersm/y2kmatrix/                                                  |
|    |1.8.8 SQL et interfaces pour bases de données.                                        |
|    |http://www.penguinpowered.com/~kmysql KMySQL is a database client for KDE that        |
|    |primarily supports MySQL.                                                             |
|    |http://java.sun.com/products/jdbc/                                                    |
|    |http://tfdec1.fys.kuleuven.ac.be/~michael/fpc-linux/mysql                             |
|    |http://www.gagme.com/mysql                                                            |
|    |http://www.amsoft.ru/easysql/                                                         |
|    |http://www.lightlink.com/hessling/rexxsql.html                                        |
|    |http://www.binevolve.com/~tdarugar/tcl-sql                                            |
|    |1.8.9 Liens sur les bases de données.                                                 |
|    |http://www.pcslink.com/~ej/dbweb.html                                                 |
|    |http://black.hole-in-the.net/guy/webdb/                                               |
|    |http://www.symbolstone.org/technology/perl/DBI/index.html                             |
|    |http://www-public.rz.uni-duesseldorf.de/~tolj                                         |
|    |http://dbasecentral.com/                                                              |
|    |http://www.Tek-Tips.com Tek-Tips Forums are 800+ independent peer-to-peer             |
|    |non-commercial support forums for Computer Professionals. Features include automatic  |
|    |e-mail notification of responses, a links library, and member confidentiality         |
|    |guaranteed.                                                                           |
|    |Il y a beaucoup de sites Web qui utilisent MySQL. Cf. section A Quelques utilisateurs |
|    |MySQL.                                                                                |
|    |2 La liste de diffusion MySQL et comment rapporter des bugs                           |
|    |2.1 Les listes de diffusion MySQL                                                     |
|    |Pour s'incrire sur la liste de diffusion (en anglais) de MySQL, envoyez un message à  |
|    |l'adresse suivante : [e-mail].                                 |
|    |Pour se désinscrire de la liste de diffusion MySQL, envoyez un message à l'adresse    |
|    |suivante : [e-mail].                                         |
|    |Seule l'adresse d'origine de votre message sera utilisée. Le sujet et le contenu du   |
|    |mail sont ignorés.                                                                    |
|    |Si votre adresse de réponse n'est pas valide, vous pouvez la spécifier explicitement. |
|    |Vous pouvez alors ajouter un signe tiret `-', suivi de votre adresse, dont l'arobase  |
|    |`@' a été remplacé par `='. Par exemple, pour inscrire l'adrsse [e-mail],    |
|    |envoyez un message à l'adresse mysql-subscribe-paul=[e-mail].     |
|    |Les mails envoyés à [e-mail] ou                                |
|    |[e-mail] sont gérés automatiquement par le robot de la liste,|
|    |ezmlm. Des informations à propos de ezmlm sont disponibles à the ezmlm Website.       |
|    |Pour envoyer un message à la liste elle même, envoyez votre message à                 |
|    |[e-mail]. Cependant, n'envoyez pas de message d'inscription ou de        |
|    |désinscription à [e-mail], car les mails envoyés la bas sont             |
|    |automatiquement envoyé à des milliers d'utilisateurs.                                 |
|    |Votre site local peut disposer de sa propre base d'utilisateurs de                    |
|    |[e-mail]. Dans ce cas, il a peut être sa propre liste de diffusion, qui  |
|    |relaient les messages de lists.mysql.com. Dans ce cas, contactez votre administrateur |
|    |pour être ajouté ou supprimé de la liste de diffusion.                                |
|    |Les listes de diffusions suivantes existent :                                         |
|    |annonces                                                                              |
|    |Cette liste sert à annoncer les nouvelles versions de MySQL et des programmes         |
|    |associés. Elle a un faible traffic, et il est préférable que tous les utilisateurs y  |
|    |soient inscrit.                                                                       |
|    |mysql                                                                                 |
|    |La liste principale de discussion à propos de MySQL. Notez bien que certains sujets   |
|    |sont traités dans des listes de diffusions séparées. Si vous postez un message sur une|
|    |mauvaise liste, vous risquez de ne pas avoir de réponse.                              |
|    |mysql-digest                                                                          |
|    |La liste mysql dans un format condensé. Cela signifie que tous les messages de la     |
|    |journée sont rassemblés en un grand message, mais une fois par jour.                  |
|    |java                                                                                  |
|    |Discussion à propos de MySQL et Java. Généralement, à propos des pilotes JDBC.        |
|    |java-digest                                                                           |
|    |La version condensée de la liste sur java.                                            |
|    |win32                                                                                 |
|    |Tout ce qui concerne MySQL sur les OS Microsoft, comme par exemple Windows NT.        |
|    |win32-digest                                                                          |
|    |La version condensée de la liste sur win32.                                           |
|    |myodbc                                                                                |
|    |Tout ce qui concerne les connexions à MySQL avec ODBC.                                |
|    |myodbc-digest                                                                         |
|    |La version condensée de la liste sur myodbc.                                          |
|    |msql-mysql-modules                                                                    |
|    |Tout ce qui concerne les connexions à MySQL avec Perl.                                |
|    |msql-mysql-modules-digest                                                             |
|    |La version condensée de la liste sur msql-mysql-modules.                              |
|    |developer                                                                             |
|    |Une liste pour ceux qui travaille sur le code de MySQL.                               |
|    |developer-digest                                                                      |
|    |La version condensée de la liste sur developer.                                       |
|    |Vous vous inscrivez ou désincrivez de ces listes de la même manière que décrit ci     |
|    |dessus. Dans votre message, utilisez simplement l'adresse de la liste qui vous        |
|    |interesse, plutôt que mysql. Par exemple, pour s'inscrire ou se désinscrire à la liste|
|    |myodbc envoyez un message à [e-mail] ou                       |
|    |[e-mail].                                                   |
|    |2.2 Poser des questions et rapporter des bugs                                         |
|    |Avant d'envoyer un rapport de bug, ou une question, suivez les instructions suivantes |
|    |:                                                                                     |
|    |Commencez par chercher dans le manuel en ligne de MySQL :                             |
|    |                                                                                      |
|    |http://www.mysql.com/Manual_chapter/manual_toc.html                                   |
|    |Nous essayons de garder le manuel à jour en le modifiant suivant, et en ajoutant des  |
|    |solutions pour les problèmes rencontrés.                                              |
|    |Recherchez dans les archives de la liste MySQL:                                       |
|    |                                                                                      |
|    |http://www.mysql.com/doc.html                                                         |
|    |Vous pouvez aussi utiliser http://www.mysql.com/search.html pour rechercher dans les  |
|    |pages web (y compris le manuel) qui sont situés à http://www.mysql.com/.              |
|    |Si vous ne trouvez pas d'information dans le manuel, ou dans les pages d'archives,    |
|    |vérifiez avec votre expert MySQL local. Si vous ne pouvez trouver aucune réponse,     |
|    |passez à la section suivante pour savoir comment envoyer un message à                 |
|    |[e-mail].                                                                |
|    |2.3 Comment rapporter des bugs et des problèmes                                       |
|    |Ecrire un rapport de bug nécessite de la patience, mais ce premier geste va économiser|
|    |votre temps, et le notre. Cette section vous aide à écrire votre rapport de bug       |
|    |correctement, de manière à ce que vous ne perdiez pas votre temps à écrire des        |
|    |messages qui ne nous servirons à rien.                                                |
|    |Nous vous encourageons à utiliser le script mysqlbug pour générer un rapport de bug   |
|    |(ou un rapport sur n'importe quel problème). mysqlbug est situés dans le dossier de la|
|    |distribution source, ou, dans la distribution binaire, dans le dossier `bin' de votre |
|    |dossier d'installation MySQL.Si vous ne pouvez pas utiliser mysqlbug, il est          |
|    |préférable d'inclure toutes les informations listées ci dessous.                      |
|    |Le script mysqlbug vous aide à générer un rapport de bug en déterminant les           |
|    |informations suivantes automatiquement : mais si vous pensez que quelque chose        |
|    |d'important manque, ajoutez le au message. Relisez attentivement cette section, et    |
|    |assurez vous que toutes les informations décrites ci dessous sont incluses dans votre |
|    |rapport.                                                                              |
|    |Gardez à l'esprit qu'il est toujours possible de répondre à un message qui contient   |
|    |trop d'information, alors que ce n'est pas possible avec un message qui en contient   |
|    |pas assez. Souvent, les rapports omettent des informations car les utilisateurs       |
|    |pensent avoir compris les causes du problème et que certains détails sont             |
|    |insignifiants. Le bon principe est le suivant : Si vous doutez de quelque chose, dites|
|    |le. Il est milles fois plus rapide d'ajouter quelques lignes dans votre rapport,      |
|    |plutôt que d'être forcé de le renvoyé encore une fois, pour complément d'information. |
|    |L'erreur la plus répandue est que les utilisateurs n'indique pas le numéro de version |
|    |de la distribution MySQL qu'ils utilisent, ou la plate forme sur laquelle ils opèrent |
|    |(y compris la version de cette plate forme). C'est une information primordiale, et 99%|
|    |des cas sont inexploitables sans cette information. Souvent, nous avons des questions |
|    |du genre : ``Pourquoi est ce que ça plante chez moi?'' et nous nous aperçevons que    |
|    |cette fonctionnalité n'est pas disponible sur la version de MySQL utilisée, ou bien   |
|    |que le bug a été corrigé dans les versions plus récentes. Parfois, l'erreur dépend de |
|    |l'OS. Dans ces cas, il est presque impossible de corriger l'erreur sans connaitre le  |
|    |nom de l'OS, et le numéro de version de la plate forme.                               |
|    |N'oubliez pas d'inclure des inforamtions sur les compilateurs, si cela a un rapport   |
|    |avec votre problème. Souvent, on trouve des erreurs dans les compilateurs, et les     |
|    |utilisateurs pensent que c'est lié à MySQL. La plus part des compilateurs sont en     |
|    |développement constants, et s'améliorent de version en version. Pour savoir si votre  |
|    |problème dépend du compilateur, nous avons besoin de savoir quel compilateur est      |
|    |utilisé. Notez que chaque problème lié à la compilation doit être considéré comme un  |
|    |bug, et rapporté de manière adéquate.                                                 |
|    |Une bonne description du problème est toujours utile dans un rapport de bug. C'est à  |
|    |dire, toutes les manipulations que vous avez faites, qui ont conduit au bug, et la    |
|    |description du bug lui même. Les meilleurs rapports inclus aussi un exemple complet   |
|    |pour reproduire le bug.                                                               |
|    |Si un programme produit un message d'erreur, il est très important d'inclure le       |
|    |message dans votre rapport! Si vous recherchez dans les archives, il est préférable   |
|    |d'utiliser le message d'erreur exact (même la casse est importante). N'essayez pas de |
|    |vous souvenir du message : faites en un copier/coller du message entier!              |
|    |Pensez à inclure les informations suivantes dans votre rapport:                       |
|    |Le numéro de version de la distribution de MySQL que vous utilisez (par exemple, MySQL|
|    |3.22.22). Vous pouvez savoir le numéro de version que vous utilisez en exécutant la   |
|    |commande mysqladmin version. mysqladmin est situé dans le dossier `bin' de votre      |
|    |dossier d'installation MySQL.                                                         |
|    |La marque et le modèle de machine que vous exploitez.                                 |
|    |Le nom de l'OS et sa verison. Pour la plus part des OS, vous pouvez avoir ces         |
|    |informations avec la commande UNIX uname -a.                                          |
|    |Parfois, la quantité de mémoire (réelle et virtuelle) est importante. En cas de doute,|
|    |incluez ces valeurs.                                                                  |
|    |Si vous utilisez une version source de MySQL, le nom et la version du compilateur est |
|    |aussi apréciable. Si vous avez une version binaire, le nom de la distribution est     |
|    |nécessaire.                                                                           |
|    |Si le problème intervient lors de la compilation, incluez l'erreur exacte, le message |
|    |d'erreur, et quelques lignes de contexte.                                             |
|    |Si une table est liée au problème, incluez le résultat de la commande mysqldump       |
|    |--no-data nom_base_de_donnees nom_table1 nom_table2 ... C'est très simple à faire, et |
|    |c'est une méthode puissante pour rassembler toutes les informations d'une table qui   |
|    |nous permettra de recréer une situation identique à la votre.                         |
|    |Pour les bugs liés à la vitesse, ou les problèmes avec les commandes SELECT vous      |
|    |devriez toujours include le résultat d'une commande EXPLAIN SELECT ..., et au moins le|
|    |nombre de lignes que votre commande SELECT doit produire. Plus vous pourrez           |
|    |transmettre d'informations, sur votre situation, plus nous pourrons vous aider. Par   |
|    |exemple, voici un très bon rapport de bug ( posté avec le script mysqlbug, bien       |
|    |entendu) : Exemple lancé depuis la ligne de commande mysql:                           |
|    |                                                                                      |
|    |mysql> SHOW VARIABLES;                                                                |
|    |mysql> EXPLAIN SELECT ...                                                             |
|    |<output-from-EXPLAIN>                                                                 |
|    |mysql> FLUSH STATUS;                                                                  |
|    |mysql> SELECT ...                                                                     |
|    |<Une courte description du résultat de SELECT,                                        |
|    |en incluant le temps de travail de la requête>                                        |
|    |mysql> SHOW STATUS;                                                                   |
|    |<output from SHOW STATUS>                                                             |
|    |Si un bug ou un problème intervient lors du fonctionnement de MySQL, essayer de nous  |
|    |fournir un script qui pourra reproduire l'anomalie. Ce script incluera tous les       |
|    |fichiers nécessaires. Plus le script sera proche de votre environnement, et mieux ce  |
|    |sera. Si vous ne pouvez pas fournir de script, vous devez au moins nous fournir       |
|    |l'affichage de mysqladmin variables extended-status processlist dans votre mail, pour |
|    |nous fournir des informations sur votre système.                                      |
|    |Si vous pensez que MySQL produit un résultat un peu inattendu, pensez à inclure non   |
|    |seulement l'étrange résultat de votre requête, mais aussi votre avis sur ce qui       |
|    |devrait être retourné, et ce qui le justifie.                                         |
|    |Lorsque vous donnez un exemple de problème, il est mieux d'utiliser des noms de       |
|    |variables, de tables, qui existent dans votre situation réelle, plutôt que d'inventer |
|    |de nouveau noms. Le problème peut être lié aux noms de colonnes, table...etc! Ces cas |
|    |sont peut être rares, mais il vaut mieux être prudent que navré. Après tout, il est   |
|    |plus facile de fournir un exemple proche de votre exemple et c'est aussi plus clair   |
|    |pour nous. Dans le cas où vous ne souhaitez pas afficher vos données à des tiers, vous|
|    |pouvez utiliser le dossier ftp pour le transférer :                                   |
|    |ftp://www.mysql.com/pub/mysql/secret/. Si les données sont vraiment très              |
|    |confidentielles, et que vous ne voulez pas nous les montrer, utilisez d'autres        |
|    |valeurs, mais considérez ce choix en dernier recours!                                 |
|    |Incluez toutes les options utilisées par les programmes adéquats, si possible. Par    |
|    |exemple, vous pouvez indiquer les options de démarrage de mysqld, et celle que vous   |
|    |utilisez pour les clients MySQL. Les options de programmes tels que mysqld et mysql,  |
|    |et le script configure sont souvent la clé de mystères. Ce n'est jamais une mauvaise  |
|    |idée de nous les transmettre, de toutes manières. Si vous utilisez des modules, tels  |
|    |que Perl ou PHP, n'oubliez pas de donner leur numéro de version.                      |
|    |Si vous n'arrivez pas à reproduire l'erreur avec quelques lignes, ou que la table est |
|    |trop grosse pour être postée sur la liste de diffusion (plus de 10 lignes), il est    |
|    |préférable de faire un dump de la table, avec mysqldump et de créer un fichier        |
|    |`README' qui décrit votre problème. Créez une archive compressée de vos fichiers avec |
|    |tar et gzip ou zip, et transférez en ftp dans le dossier                              |
|    |ftp://www.mysql.com/pub/mysql/secret/. Puis, envoyez une courte description de votre  |
|    |problème sur la liste de diffusion.                                                   |
|    |Si vos questions sont liées aux droits, ajoutez les données de mysqlaccess, celui de  |
|    |mysqladmin reload et tous les messages d'erreur que vous obtenez en vous connectant.  |
|    |Lorsque vous testez les droits, il est préférable de faire tourner d'abord            |
|    |mysqlaccess. Après ça, excécutez la commande mysqladmin reload version, et en dernier |
|    |ressort, essayez de vous connectez avec le programme qui pose problème. mysqlaccess   |
|    |est situé dans le dossier `bin' de votre dossier d'installation.                      |
|    |Si vosu avez un patch pour un bug, c'est bien. Mais ne supposez jamais que ce patch   |
|    |est tout ce dont nous révions, ou même que nous allons l'utiliser si vous ne          |
|    |fournissez pas les informations nécessaires pour tester le bug. Nous pouvons          |
|    |rencontrer des problèmes avec votre patch, voire même, nous pouvons ne pas le         |
|    |comprendre. Dans ce cas, nous ne pourrons pas l'utiliser. Si nous ne pouvons pas      |
|    |vérifier l'objectif du patch, nous ne l'utiliserons pas. Les cas de tests nous seront |
|    |d'un précieux secours. Montrez bien toutes les situations que le patch prend en       |
|    |compte. Si nous trouvons un effet de bord (même rare), ou un cas extrême que le patche|
|    |ne gère pas, il risque d'être inutile.                                                |
|    |Toutes les tentatives de deviner l'origine du bug, pourquoi il survient, ou de quoi il|
|    |découle sont généralement fausses. Il arrive que même nous, avec l'aide d'un débugger,|
|    |ne pouvons pas toujours determiner la cause réelle du bug.                            |
|    |Indiquez dans votre mail que vous avez vérifié le manuel de référence, et les         |
|    |archives, de manière à montrer que vous avez déjà essayé de résoudre le problème vous |
|    |même.                                                                                 |
|    |Si vous avez une erreur parse error, prenez le temps de bien vérifier votre syntaxe.  |
|    |Si vous ne pouvez pas trouver d'erreur, il est fort probable que votre version de     |
|    |MySQL ne supporte par la requête que vous utilisez. Si vous utilisez la version       |
|    |courant et que le manuel de référence http://www.mysql.com/doc.html ne couvre pas la  |
|    |syntaxe que vous utilisez, c'est que MySQL ne supporte pas votre requête. Dans ce cas,|
|    |votre seul option est d'implémenter vous même l'option ou d'envoyer un email à        |
|    |[e-mail] et demandez à ce qu'elle soit implémentée. Si le manuel     |
|    |couvre votre syntaxe, mais que vous avez une vieille version de MySQL, vérifiez       |
|    |l'historique de MySQL pour voir quand la syntaxe a été implémentée. D Historique des  |
|    |versions de MySQL. Dans ce cas, il vous reste la possibilité de vous mettre à jour    |
|    |avec une nouvelle version de MySQL.                                                   |
|    |Si vous avez un problème tel que vos données semblent corrompues, ou que vous avez des|
|    |erreurs lorsque vous accédez à une table particulière, vous devriez essayer de        |
|    |vérifier et réparer vos tables avec isamchk. 13 Maintenance d'un serveur MySQL.       |
|    |Si vos tables se corrompent souvent, vous pouvez essayer de voir quand cela arrive, et|
|    |pourquoi! Dans ce cas, `mysql-data-directory/'hostname'.err' peut contenir certaines  |
|    |informations sur ce qui est passé. N'oubliez pas d'ajouter toutes les informations    |
|    |utiles dans votre rapport de bug. Normalement, mysqld ne crashe JAMAIS de table s'il  |
|    |n'a pas été tué durant une modification. Si vous pouvez trouver la source de la fin du|
|    |processus mysqld, il est plus facile pour nous de vous fournir un correctif.          |
|    |Si possible, téléchargez la version la plus récente de MySQL et vérifiez si cela      |
|    |résoud votre problème. Toutes les versions de MySQL sont testés de manière exhaustive,|
|    |et devrait fonctionner sans problème. Nous essayons de rendre nos developpement       |
|    |compatibles avec les anciennes versions, ce qui vous permettra de changer de version  |
|    |de MySQL en quelques minutes! 4.3 Quelle version de MySQL utiliser.                   |
|    |Si vous être un client du support, n'envoyez pas le rapport en double sur l'adresse   |
|    |pour voir si quelqu'un expérimenté peut résoudre votre problème.                      |
|    |Pour savoir comment rapporter à propos de MyODBC, allez à 16.2 Comment rapporter des  |
|    |bugs avec MyODBC.                                                                     |
|    |Pour des solutions aux problèmes courants, reportez vous à 18 Problèmes et erreurs    |
|    |fréquents.                                                                            |
|    |Lorsque des informations vous sont envoyées individuellement, et pas à la liste de    |
|    |diffusion, il est de bon ton de rassembler toutes les réponses, et de les envoyer à la|
|    |liste de diffusion pour que le bénéfices des réponses profite à tous.                 |
|    |2.4 Règles pour répondre aux questions sur la liste de diffusion                      |
|    |Si vous pensez que vous avec une réponse d'interêt général, vous voudrez surement     |
|    |envoyer un mail sur la liste de diffusion, plutôt que de répondre uniquement à la     |
|    |personne qui a posé la question. Essayez de rendre votre réponse aussi générale que   |
|    |possible, pour que tous ceux qui ne connaissent pas le problème initiale puisse       |
|    |comprendre. Lorsque vous envoyez votre réponse, vérifiez que vous n'etes pas en double|
|    |avec une autre réponse.                                                               |
|    |Dans votre réponse, essayez de résumer la question; ne vous sentez pas obligé de citer|
|    |toute la question.                                                                    |
|    |N'envoyez pas de mail avec votre navigateur HTML. De nombreux utilisateurs ne lisent  |
|    |pas leur mail avec un navigateur.                                                     |
|    |3 Support et licences MySQL                                                           |
|    |This chapter describes MySQL licensing and support arrangements, including:           |
|    |Our licensing policies for non-Microsoft and Microsoft operating systems              |
|    |The copyrights under which MySQL is distributed ( 3.2 Copyrights de MySQL)            |
|    |Sample situations illustrating when a license is required ( 3.4 Exemple de licences)  |
|    |Licensing and support costs ( 3.5 Licences et couts du support MySQL), and support    |
|    |benefits ( 3.6 Types de support commercial)                                           |
|    |3.1 Politique de licence MySQL                                                        |
|    |The formal terms of the license for non-Microsoft operating systems such as Unix or   |
|    |OS/2 are specified in J Licence MySQL pour les sytèmes d'exploitation non-Microsoft.  |
|    |Basically, our licensing policy is as follows:                                        |
|    |For normal internal use, MySQL generally costs nothing. You do not have to pay us if  |
|    |you do not want to.                                                                   |
|    |A license is required if:                                                             |
|    |You sell the MySQL server directly or as a part of another product or service         |
|    |You charge for installing and maintaining a MySQL server at some client site          |
|    |You include MySQL in a distribution that is non redistributable and you charge for    |
|    |some part of that distribution                                                        |
|    |For circumstances under which a MySQL license is required, you need a license per     |
|    |machine that runs the mysqld server. However, a multiple-CPU machine counts as a      |
|    |single machine, and there is no restriction on the number of MySQL servers that run on|
|    |one machine, or on the number of clients concurrently connected to a server running on|
|    |that machine!                                                                         |
|    |You do not need a license to include client code in commercial programs. The client   |
|    |access part of MySQL is in the public domain. The mysql command line client includes  |
|    |code from the readline library that is under the GNU Public License.                  |
|    |For customers who have purchased 10 licenses or a high enough level of support, we    |
|    |provide additional functionality. Currently, this means we provide the pack_isam      |
|    |utility for creating fast compressed read-only databases. (The server includes support|
|    |for reading such databases but not the packing tool used to create them.) If support  |
|    |agreements generate sufficient revenue, we will probably release this tool under the  |
|    |same license as the MySQL server.                                                     |
|    |If your use of MySQL does not require a license, but you like MySQL and want to       |
|    |encourage further development, you are certainly welcome to purchase a license anyway.|
|    |                                                                                      |
|    |If you use MySQL in a commercial context such that you profit by its use, we ask that |
|    |you further the development of MySQL by purchasing some level of support. We feel that|
|    |if MySQL helps your business, it is reasonable to ask that you help MySQL. (Otherwise,|
|    |if you ask us support questions, you are not only using for free something into which |
|    |we've put a lot a work, you're asking us to provide free support, too.)               |
|    |For use under Microsoft operating systems (Win95/Win98/WinNT), you need a MySQL       |
|    |license after a trial period of 30 days, with the exception that licenses may be      |
|    |obtained upon request at no cost for educational use or for university- or            |
|    |government-sponsored research settings. K Licence MySQL pour les OS Microsoft. A      |
|    |shareware version of MySQL-Win32 that you can try before buying is available at       |
|    |http://www.mysql.com/mysql_w32.htmy. After you have paid, you will get a password that|
|    |will enable you to access the newest MySQL-Win32 version.                             |
|    |If you have any questions as to whether or not a license is required for your         |
|    |particular use of MySQL, please contact us. 3.5.2 Contacts.                           |
|    |If you require a MySQL license, the easiest way to pay for it is to use the license   |
|    |form at TcX's secure server at https://www.mysql.com/license.htmy. Other forms of     |
|    |payment are discussed in 3.5.1 Informations pratique de paiement.                     |
|    |3.2 Copyrights de MySQL                                                               |
|    |There are several different copyrights on the MySQL distribution:                     |
|    |The MySQL-specific source needed to build the mysqlclient library and programs in the |
|    |`client' directory is in the public domain. Each file that is in the public domain has|
|    |a header which clearly states so. This includes everything in the `client' directory  |
|    |and some parts of the mysys, mystring and dbug libraries.                             |
|    |Some small parts of the source (GNU getopt) are covered by the ``GNU LIBRARY LIBRARY  |
|    |GENERAL PUBLIC LICENSE''. See the `mysys/COPYING.LIB' file.                           |
|    |Some small parts of the source (GNU readline) are covered by the ``GNU GENERAL PUBLIC |
|    |LICENSE''. See the `readline/COPYING' file.                                           |
|    |Some parts of the source (the regexp library) are covered by a Berkeley style         |
|    |copyright.                                                                            |
|    |The other source needed for the MySQL server on non-Microsoft platforms is covered by |
|    |the ``MySQL FREE PUBLIC LICENSE'', which is based on the ``Aladdin FREE PUBLIC        |
|    |LICENSE.'' J Licence MySQL pour les sytèmes d'exploitation non-Microsoft. When running|
|    |MySQL on any Microsoft operating system, other licensing applies.                     |
|    |The following points set forth the philosophy behind our copyright policy:            |
|    |The SQL client library should be totally free so that it can be included in commercial|
|    |products without limitations.                                                         |
|    |People who want free access to the software into which we have put a lot of work can  |
|    |have it, so long as they do not try to make money directly by distributing it for     |
|    |profit.                                                                               |
|    |People who want the right to keep their own software proprietary, but also want the   |
|    |value from our work, can pay for the privilege.                                       |
|    |That means normal in-house use is FREE. But if you use MySQL for something important  |
|    |to you, you may want to help further its development by purchasing a license or a     |
|    |support contract. 3.6 Types de support commercial.                                    |
|    |3.2.1 Modifications ultérieures possibles du copyright                                |
|    |We may choose to distribute older versions of MySQL with the GPL in the future.       |
|    |However, these versions will be identified as GNU MySQL. Also, all copyright notices  |
|    |in the relevant files will be changed to the GPL.                                     |
|    |3.3 Distribution commerciale de MySQL                                                 |
|    |This section is a clarification of the license terms that are set forth in the ``MySQL|
|    |FREE PUBLIC LICENSE'' (FPL). J Licence MySQL pour les sytèmes d'exploitation          |
|    |non-Microsoft.                                                                        |
|    |MySQL may be used freely, including by commercial entities for evaluation or          |
|    |unsupported internal use. However, distribution for commercial purposes of MySQL, or  |
|    |anything containing or derived from MySQL in whole or in part, requires a written     |
|    |commercial license from TcX AB, the sole entity authorized to grant such licenses.    |
|    |You may not include MySQL ``free'' in a package containing anything for which a charge|
|    |is being made, except as noted below.                                                 |
|    |The intent of the exception provided in the second clause of the license is to allow  |
|    |commercial organizations operating an FTP server or a bulletin board to distribute    |
|    |MySQL freely from it, provided that:                                                  |
|    |The organization complies with the other provisions of the FPL, which include among   |
|    |other things a requirement to distribute the full source code of MySQL and of any     |
|    |derived work, and to distribute the FPL itself along with MySQL;                      |
|    |The only charge for downloading MySQL is a charge based on the distribution service   |
|    |and not one based on the content of the information being retrieved (i.e., the charge |
|    |would be the same for retrieving a random collection of bits of the same size);       |
|    |The server or BBS is accessible to the general public, i.e., the phone number or IP   |
|    |address is not kept secret, and anyone may obtain access to the information (possibly |
|    |by paying a subscription or access fee that is not dependent on or related to         |
|    |purchasing anything else).                                                            |
|    |If you want to distribute software in a commercial context that incorporates MySQL and|
|    |you do not want to meet these conditions, you should contact TcX AB to find out about |
|    |commercial licensing, which involves a payment. The only ways you legally can         |
|    |distribute MySQL or anything containing MySQL are by distributing MySQL under the     |
|    |requirements of the FPL, or by getting a commercial license from TcX AB.              |
|    |3.4 Exemple de licences                                                               |
|    |This section describes some situations illustrating whether or not you must license   |
|    |the MySQL server. Generally these examples involve providing MySQL as part of a       |
|    |product or service that you are selling to a customer, or requiring that MySQL be used|
|    |in conjunction with your product. In such cases, it is your responsibility to obtain a|
|    |license for the customer if one is necessary. (This requirement is waived if your     |
|    |customer already has a MySQL license. But the seller must send customer information   |
|    |and the license number to TcX, and the license must be a full license, not an OEM     |
|    |license.)                                                                             |
|    |Note that a single MySQL license covers any number of CPUs/users/customers/mysqld     |
|    |servers on a machine!                                                                 |
|    |3.4.1 Vente de produits qui utilisent MySQL                                           |
|    |To determine whether or not you need a MySQL license when selling your application,   |
|    |you should ask whether the proper functioning of your application is contingent on the|
|    |use of MySQL and whether you include MySQL with your product. There are several cases |
|    |to consider:                                                                          |
|    |Does your application require MySQL to function properly? If your product requires    |
|    |MySQL, you need a license for any machine that runs the mysqld server. For example, if|
|    |you've designed your application around MySQL, then you've really made a commercial   |
|    |product that requires the engine, so you need a license. If your application does not |
|    |require MySQL, you need not obtain a license. For example, if MySQL just added some   |
|    |new optional features to your product (such as adding logging to a database if MySQL  |
|    |is used rather than logging to a text file), it should fall within normal use, and a  |
|    |license would not be required. In other words, you need a license if you sell a       |
|    |product designed specifically for use with MySQL or that requires the MySQL server to |
|    |function at all. This is true whether or not you provide MySQL for your client as part|
|    |of your product distribution. It also depends on what you're doing for the client. Do |
|    |you plan to provide your client with detailed instructions on installing MySQL with   |
|    |your software? Then your product may be contingent on the use of MySQL; if so, you    |
|    |need to buy a license. If you are simply tying into a database that you expect already|
|    |to have been installed by the time your software is purchased, then you probably don't|
|    |need a license.                                                                       |
|    |Do you include MySQL in a distribution and charge for that distribution? If you       |
|    |include MySQL with a distribution that you sell to customers, you will need a license |
|    |for any machine that runs the mysqld server, because in this case you are selling a   |
|    |system that includes MySQL. This is true whether the use of MySQL with your product is|
|    |required or optional.                                                                 |
|    |Do you neither require for your product nor include MySQL with it? Suppose you want to|
|    |sell a product that is designed generally to use ``some database'' and that can be    |
|    |configured to use any of several supported alternative database systems (MySQL,       |
|    |PostgreSQL, or something else). That is, your product does not not require MySQL, but |
|    |can support any database with a base level of functionality, and you don't rely on    |
|    |anything that only MySQL supports. Does one of you owe us money if your customer      |
|    |actually does choose to use MySQL? In this case, if you don't provide, obtain or set  |
|    |up MySQL for the customer should the customer decide to use it, neither of you need a |
|    |license. If you do perform that service, see MySQL services.                          |
|    |3.4.2 Vente de services MySQL                                                         |
|    |If you perform MySQL installation on a client's machine and any money changes hands   |
|    |for the service (directly or indirectly), then you must buy a MySQL license.          |
|    |If you sell an application for which MySQL is not strictly required but can be used, a|
|    |license may be indicated, depending on how MySQL is set up. Suppose your product      |
|    |neither requires MySQL nor includes it in your product distribution, but can be       |
|    |configured to use MySQL for those customers who so desire. (This would be the case,   |
|    |for example, if your product can use any of a number of database engines.)            |
|    |If the customer obtains and installs MySQL, no license is needed. If you perform that |
|    |service for your customer, then a license is needed because then you are selling a    |
|    |service that includes MySQL.                                                          |
|    |3.4.3 ISP MySQL                                                                       |
|    |Internet Service Providers (ISPs) often host MySQL servers for their customers.       |
|    |If you are an ISP that allows customers to install and administer MySQL for themselves|
|    |on your machine with no assistance from you, neither you nor your customer need a     |
|    |MySQL license.                                                                        |
|    |If you charge for MySQL installation and administrative support as part of your       |
|    |customer service, then you need a license because you are selling a service that      |
|    |includes MySQL.                                                                       |
|    |3.4.4 Utiliser un serveur web avec MySQL                                              |
|    |If you use MySQL in conjunction with a web server, you don't have to pay for a        |
|    |license.                                                                              |
|    |This is true even if you run a commercial web server that uses MySQL, since you are   |
|    |not selling MySQL itself. However, in this case we would like you to purchase MySQL   |
|    |support, because MySQL is helping your enterprise.                                    |
|    |3.5 Licences et couts du support MySQL                                                |
|    |Our current license prices are shown below. All prices are in US Dollars. If you pay  |
|    |by credit card, the currency is EURO (European Union Euro) so the prices will differ  |
|    |slightly.                                                                             |
|    |Number of licenses                                                                    |
|    |Price per copy                                                                        |
|    |Total                                                                                 |
|    |                                                                                      |
|    |1                                                                                     |
|    |US $200                                                                               |
|    |US $200                                                                               |
|    |                                                                                      |
|    |10 pack                                                                               |
|    |US $150                                                                               |
|    |US $1500                                                                              |
|    |                                                                                      |
|    |50 pack                                                                               |
|    |US $120                                                                               |
|    |US $6000                                                                              |
|    |                                                                                      |
|    |For high volume (OEM) purchases, the following prices apply:                          |
|    |Number of licenses                                                                    |
|    |Price per copy                                                                        |
|    |Minimum at one time                                                                   |
|    |Minimum payment                                                                       |
|    |                                                                                      |
|    |100-999                                                                               |
|    |US $40                                                                                |
|    |100                                                                                   |
|    |US $4000                                                                              |
|    |                                                                                      |
|    |1000-2499                                                                             |
|    |US $25                                                                                |
|    |200                                                                                   |
|    |US $5000                                                                              |
|    |                                                                                      |
|    |2500-4999                                                                             |
|    |US $20                                                                                |
|    |400                                                                                   |
|    |US $8000                                                                              |
|    |                                                                                      |
|    |For OEM purchases, you must act as the middle-man for eventual problems or extension  |
|    |requests from your users. We also require that OEM customers have at least an extended|
|    |email support contract.                                                               |
|    |If you have a low-margin high-volume product, you can always talk to us about other   |
|    |terms (for example, a percent of the sale price). If you do, please be informative    |
|    |about your product, pricing, market and any other information that may be relevant.   |
|    |After buying 10 MySQL licenses, you will get a personal copy of the pack_isam utility.|
|    |You are not allowed to redistribute this utility but you can distribute tables packed |
|    |with it.                                                                              |
|    |A full-price license is not a support agreement and includes very minimal support.    |
|    |This means that we try to answer any relevant question. If the answer is in the       |
|    |documentation, we will direct you to the appropriate section. If you have not         |
|    |purchased a license or support, we probably will not answer at all.                   |
|    |If you discover what we consider a real bug, we are likely to fix it in any case. But |
|    |if you pay for support we will notify you about the fix status instead of just fixing |
|    |it in a later release.                                                                |
|    |More comprehensive support is sold separately. Descriptions of what each level of     |
|    |support includes are given in 3.6 Types de support commercial. Costs for the various  |
|    |types of commercial support are shown below. Support level prices are in EURO         |
|    |(European Union Euro). One EURO is about 1.17 USD.                                    |
|    |Type of support                                                                       |
|    |Cost per year                                                                         |
|    |                                                                                      |
|    |Basic email support                                                                   |
|    |EURO 170                                                                              |
|    |                                                                                      |
|    |Extended email support                                                                |
|    |EURO 1000                                                                             |
|    |                                                                                      |
|    |Login support                                                                         |
|    |EURO 2000                                                                             |
|    |                                                                                      |
|    |Extended login support                                                                |
|    |EURO 5000                                                                             |
|    |                                                                                      |
|    |You may upgrade from any lower level of support to a higher level of support for the  |
|    |difference between the prices of the two support levels.                              |
|    |3.5.1 Informations pratique de paiement                                               |
|    |Currently we can take SWIFT payments, cheques or credit cards.                        |
|    |Payment should be made to:                                                            |
|    |                                                                                      |
|    |Postgirot Bank AB                                                                     |
|    |105 06 STOCKHOLM, SWEDEN                                                              |
|    |                                                                                      |
|    |TCX DataKonsult AB                                                                    |
|    |BOX 6434                                                                              |
|    |11382 STOCKHOLM, SWEDEN                                                               |
|    |                                                                                      |
|    |SWIFT address: PGSI SESS                                                              |
|    |Account number: 96 77 06 - 3                                                          |
|    |Specify: license and/or support and your name and email address.                      |
|    |In Europe and Japan you can use EuroGiro (that should be less expensive) to the same  |
|    |account.                                                                              |
|    |If you want to pay by cheque, make it payable to ``Monty Program KB'' and mail it to  |
|    |the address below:                                                                    |
|    |                                                                                      |
|    |TCX DataKonsult AB                                                                    |
|    |BOX 6434                                                                              |
|    |11382 STOCKHOLM, SWEDEN                                                               |
|    |If you want to pay by credit card over the Internet, you can use TcX's secure license |
|    |form.                                                                                 |
|    |You can also print a copy of the license form, fill it in and send it by fax to:      |
|    |[phone]                                                                       |
|    |If you want us to bill you, you can use the license form and write ``bill us'' in the |
|    |comment field. You can also mail a message to with your company information and ask us|
|    |to bill you.                                                                          |
|    |3.5.2 Contacts                                                                        |
|    |For commercial licensing, or if you have any questions about any of the information in|
|    |this section, please contact the MySQL licensing team. The much preferred méthode is  |
|    |by E-Mail to these may take much longer (Fax [phone]).                        |
|    |                                                                                      |
|    |David Axmark                                                                          |
|    |Detron HB                                                                             |
|    |Kungsgatan 65 B                                                                       |
|    |753 21 UPPSALA                                                                        |
|    |SWEDEN                                                                                |
|    |Voice Phone [phone]     (Timezone GMT+1. Swedish and English spoken)          |
|    |3.6 Types de support commercial                                                       |
|    |3.6.1 Support email basique                                                           |
|    |Basic email support is a very inexpensive support option and should be thought of more|
|    |as a way to support our development of MySQL than as a real support option.           |
|    |At this support level, the MySQL mailing lists are the preferred means of             |
|    |communication. Questions normally should be mailed to the primary mailing list        |
|    |([e-mail]) or one of the other regular lists (for example,               |
|    |[e-mail] for Windows-related MySQL questions), as someone else     |
|    |already may have experienced and solved the problem you have. 2.2 Poser des questions |
|    |et rapporter des bugs.                                                                |
|    |However, by purchasing basic email support, you also have access to the support       |
|    |address [e-mail], which is not available as part of the minimal support|
|    |that you get by purchasing a MySQL license. This means that for especially critical   |
|    |questions, you can cross-post your message to [e-mail]. (If the message|
|    |contains sensitive data, you should post only to [e-mail].)            |
|    |REMEMBER! to ALWAYS include your registration number and expiration date when you send|
|    |a message to                                                                          |
|    |Basic email support includes the following types of service:                          |
|    |If your question is already answered in the manual, we will inform you of the correct |
|    |section in which you can find the answer. If the answer is not in the manual, we will |
|    |point you in the right direction to solve your problem.                               |
|    |We guarantee a timely answer for your email messages. We can't guarantee that we can  |
|    |solve any problem, but at least you will receive an answer if we can contact you by   |
|    |email.                                                                                |
|    |We will help with unexpected problems when you install MySQL from a binary            |
|    |distribution on supported platforms. This level of support does not cover installing  |
|    |MySQL from a source distribution. ``Supported'' platforms are those for which MySQL is|
|    |known to work. 4.2 Systèmes d'exploitation supportés par MySQL.                       |
|    |We will help you with bugs and missing features. Any bugs that are found are fixed for|
|    |the next MySQL release. If the bug is critical for you, we will mail you a patch for  |
|    |it as soon the bug is fixed. Critical bugs always have the highest priority for us, to|
|    |ensure that they are fixed as soon as possible.                                       |
|    |Your suggestions for the further development of MySQL will be taken into              |
|    |consideration. By taking email support you have already helped the further development|
|    |of MySQL. If you want to have more input, upgrade to a higher level of support.       |
|    |If you want us to help optimize your system, you must upgrade to a higher level of    |
|    |support.                                                                              |
|    |3.6.2 Support email étendu                                                            |
|    |Extended email support includes everything in basic email support with these          |
|    |additions:                                                                            |
|    |Your email will be dealt with before mail from basic email support users and          |
|    |non-registered users.                                                                 |
|    |Your suggestions for the further development of MySQL will receive strong             |
|    |consideration. Simple extensions that suit the basic goals of MySQL are implemented in|
|    |a matter of days. By taking extended email support you have already helped the further|
|    |development of MySQL.                                                                 |
|    |We include a binary version of the pack_isam packing tool for creating fast compressed|
|    |read-only databases (it does not support BLOB or TEXT types yet). The current server  |
|    |includes support for reading such databases but not the packing tool used to create   |
|    |them.                                                                                 |
|    |Typical questions that are covered by extended email support are:                     |
|    |We will answer and (within reason) solve questions that relate to possible bugs in    |
|    |MySQL. As soon as the bug is found and corrected, we will mail a patch for it.        |
|    |We will help with unexpected problems when you install MySQL from a source or binary  |
|    |distribution on supported platforms.                                                  |
|    |We will answer questions about missing features and offer hints how to work around    |
|    |them.                                                                                 |
|    |We will provide hints on optimizing mysqld for your situation.                        |
|    |You are allowed to influence the priority of items on the MySQL TODO. This will ensure|
|    |that the features you really need will be implemented sooner than they might be       |
|    |otherwise.                                                                            |
|    |3.6.3 Support de login                                                                |
|    |Login support includes everything in extended email support with these additions:     |
|    |Your email will be dealt with even before mail from extended email support users.     |
|    |Your suggestions for the further development of MySQL will be taken into very high    |
|    |consideration. Realistic extensions that can be implemented in a couple of hours and  |
|    |that suit the basic goals of MySQL will be implemented as soon as possible.           |
|    |If you have a very specific problem, we can try to log in on your system to solve the |
|    |problem ``in place.''                                                                 |
|    |Like any database vendor, we can't guarantee that we can rescue any data from crashed |
|    |tables, but if the worst happens we will help you rescue as much as possible. MySQL   |
|    |has proven itself very reliable, but anything is possible due to circumstances beyond |
|    |our control (for example, if your system crashes or someone kills the server by       |
|    |executing a kill -9 command).                                                         |
|    |We will provide hints on optimizing your system and your queries.                     |
|    |You are allowed to call a MySQL developer (in moderation) and discuss your            |
|    |MySQL-related problems.                                                               |
|    |3.6.4 Support de login étendu                                                         |
|    |Extended login support includes everything in login support with these additions:     |
|    |Your email has the highest possible priority.                                         |
|    |We will actively examine your system and help you optimize it and your queries. We may|
|    |also optimize and/or extend MySQL to better suit your needs.                          |
|    |You may also request special extensions just for you. For example:                    |
|    |                                                                                      |
|    |mysql> select MY_CALCULATION(nom_colonne1,nom_colonne2) from nom_table;               |
|    |We will provide a binary distribution of all important MySQL releases for your system,|
|    |as long as we can get an account on a similar system. In the worst case, we may       |
|    |require access to your system to be able to create a binary distribution.             |
|    |If you can provide accommodations and pay for traveler fares, you can even get a MySQL|
|    |developer to visit you and offer you help with your troubles. Extended login support  |
|    |entitles you to one personal encounter per year, but we are as always very flexible   |
|    |towards our customers!                                                                |
|    |4 Instalation de MySQL                                                                |
|    |This chapter describes how to obtain and install MySQL:                               |
|    |For a list of sites from which you can obtain MySQL, see Getting MySQL.               |
|    |To see which platforms are supported, see 4.2 Systèmes d'exploitation supportés par   |
|    |MySQL.                                                                                |
|    |Several versions of MySQL are available, in both binary and source distributions. To  |
|    |determine which version and type of distribution you should use, see 4.4 Comment et   |
|    |quand sont générées les mises à jour.                                                 |
|    |Installation instructions for binary and source distributions are described in 4.6    |
|    |Installer une version binaire de MySQL, and 4.7 Installer une version source de MySQL.|
|    |Each set of instructions includes a section on system-specific problems you may run   |
|    |into.                                                                                 |
|    |For post-installation procedures, see 4.15 Paramètrage post-installation et tests.    |
|    |These procedures apply whether you install MySQL using a binary or source             |
|    |distribution.                                                                         |
|    |4.1 Comment obtenir MySQL                                                             |
|    |Check the MySQL home page for information about the current version and for           |
|    |downloading instructions.                                                             |
|    |However, the Internet connection at TcX is not so fast; we would prefer that you do   |
|    |the actual downloading from one of the mirror sites listed below.                     |
|    |Please report bad or out of date mirrors to [e-mail].                      |
|    |Europe:                                                                               |
|    |[pic]Austria [Univ. of Technology/Vienna] WWW FTP                                     |
|    |[pic]Bulgaria [Naturella] FTP                                                         |
|    |[pic]Croatia [HULK] WWW FTP                                                           |
|    |[pic]Czech Republic [Masaryk University in Brno] WWW FTP                              |
|    |[pic]Denmark [Ake] WWW                                                                |
|    |[pic]Denmark [SunSITE] WWW FTP                                                        |
|    |[pic]Estonia [OKinteractive] WWW                                                      |
|    |[pic]France [minet] WWW                                                               |
|    |[pic]Finland [EUnet] WWW                                                              |
|    |[pic]Finland [clinet] FTP                                                             |
|    |[pic]Germany [Bonn University, Bonn] WWW FTP                                          |
|    |[pic]Germany [Wolfenbuettel] WWW FTP                                                  |
|    |[pic]Germany [Staufen] WWW                                                            |
|    |[pic]Germany [Cable & Wireless] FTP                                                   |
|    |[pic]Greece [NTUA, Athens] WWW FTP                                                    |
|    |[pic]Italy [Teta Srl] WWW                                                             |
|    |[pic]Poland [Sunsite] WWW FTP                                                         |
|    |[pic]Portugal [lerianet] WWW FTP                                                      |
|    |[pic]Russia [DirectNet] WWW                                                           |
|    |[pic]Russia [IZHCOM] WWW FTP                                                          |
|    |[pic]Russia [Scientific Center/Chernogolovka] FTP                                     |
|    |[pic]Romania [Timisoara] WWW FTP                                                      |
|    |[pic]Romania [Bucharest] WWW FTP                                                      |
|    |[pic]Sweden [Sunet] WWW FTP                                                           |
|    |[pic]Switzerland [Sunsite] WWW FTP                                                    |
|    |[pic]UK [Omnipotent/UK] WWW FTP                                                       |
|    |[pic]UK [PLiG/UK] WWW FTP                                                             |
|    |[pic]UK [SunSITE] WWW FTP                                                             |
|    |[pic]Ukraine [PACO] WWW FTP                                                           |
|    |North America:                                                                        |
|    |[pic]Canada [Tryc] WWW                                                                |
|    |[pic]USA [Hurricane Electric/San Jose] WWW                                            |
|    |[pic]USA [Netcasting/West Coast] FTP                                                  |
|    |[pic]USA [Circle Net/North Carolina] WWW                                              |
|    |[pic]USA [Gina net/Florida] WWW                                                       |
|    |[pic]USA [pingzero/Los Angeles] WWW                                                   |
|    |[pic]USA [DIGEX] FTP                                                                  |
|    |South America:                                                                        |
|    |[pic]Chile [Vision] WWW                                                               |
|    |Asia:                                                                                 |
|    |[pic]China [Freecode] WWW                                                             |
|    |[pic]Korea [KREONet] WWW                                                              |
|    |[pic]Japan [Soft Agency] WWW                                                          |
|    |[pic]Japan [Nagoya Syouka University] WWW FTP                                         |
|    |[pic]Singapore [HJC] WWW FTP                                                          |
|    |[pic]Taiwan [HT] WWW                                                                  |
|    |Australia:                                                                            |
|    |[pic]Australia [AARNet/Queensland] WWW FTP                                            |
|    |[pic]Australia [Tas] WWW FTP                                                          |
|    |[pic]Australia [Blue Planet/Melbourne] WWW                                            |
|    |[pic]Australia [ITworks Consulting/Victoria] WWW                                      |
|    |Africa:                                                                               |
|    |[pic]South-Africa [Mweb/] WWW                                                         |
|    |[pic]South-Africa [The Internet Solution/Johannesburg] FTP                            |
|    |4.2 Systèmes d'exploitation supportés par MySQL                                       |
|    |We use GNU Autoconf so it is possible to port MySQL to all modern systems with working|
|    |Posix threads and a C++ compiler. (To compile only the client code, a C++ compiler is |
|    |required but not threads.) We use and develop the software ourselves primarily on Sun |
|    |Solaris (versions 2.5 & 2.6) and to a lesser extent on RedHat Linux 5.0.              |
|    |MySQL has been reported to compile sucessfully on the following operating             |
|    |system/thread package combinations. Note that for many operating systems, the native  |
|    |thread support works only in the latest versions.                                     |
|    |AIX 4.x with native threads                                                           |
|    |BSDI 2.x with the included MIT-pthreads package                                       |
|    |BSDI 3.0, 3.1 and 4.x with native threads                                             |
|    |DEC UNIX 4.x with native threads                                                      |
|    |FreeBSD 2.x with the included MIT-pthreads package                                    |
|    |FreeBSD 3.x with native threads                                                       |
|    |HP-UX 10.20 with the included MIT-pthreads package                                    |
|    |HP-UX 11.x with the native threads.                                                   |
|    |Linux 2.0+ with LinuxThreads 0.7.1 or glibc 2.0.7                                     |
|    |NetBSD 1.3/1.4 Intel and NetBSD 1.3 Alpha (Requires GNU make)                         |
|    |OpenBSD 2.x with the included MIT-pthreads package                                    |
|    |OS/2 Warp 3, FixPack 29 and OS/2 Warp 4, FixPack 4                                    |
|    |SGI Irix 6.x with native threads                                                      |
|    |Solaris 2.5, 2.6 and 2.7 with native threads on SPARC and x86                         |
|    |SunOS 4.x with the included MIT-pthreads package                                      |
|    |SCO OpenServer with a recent port of the FSU Pthreads package                         |
|    |SCO UnixWare 7.0.1                                                                    |
|    |Tru64 Unix                                                                            |
|    |Win95, Win98 and NT (the newest version is currently available only for users with a  |
|    |MySQL license or MySQL email support). For those who wish to test before they buy, we |
|    |have released MySQL 3.21.29 (an older version) as shareware.                          |
|    |4.3 Quelle version de MySQL utiliser                                                  |
|    |The first decision to make is whether you want to use the latest development release  |
|    |or the last stable release:                                                           |
|    |Normally, if you are beginning to use MySQL for the first time or trying to port it to|
|    |some system for which there is no binary distribution, we recommend going with the    |
|    |development release (currently 3.22.x). This is because there are usually no really   |
|    |serious bugs in the development release, and you can easily test it on your machine   |
|    |with the crash-me and benchmark tests. 11 La suite de tests de MySQL.                 |
|    |Otherwise, if you are running an old system and want to upgrade, but don't want to    |
|    |take chances with 3.22, you should upgrade to 3.21.33. We have tried to fix only fatal|
|    |bugs and make small, relatively safe changes to that version.                         |
|    |The second decision to make is whether you want to use a source distribution or a     |
|    |binary distribution:                                                                  |
|    |If you want to run MySQL on a platform for which a current binary distribution exists,|
|    |use that. Generally, it will be easier to install than a source distribution.         |
|    |If you want to read (and/or modify) the C and C++ code that makes up MySQL, you should|
|    |get a source distribution. The source code is always the ultimate manual. Source      |
|    |distributions also contain more tests and examples than binary distributions.         |
|    |The MySQL naming scheme uses release numbers that consist of three numbers and a      |
|    |suffix. For example, a release name like mysql-3.21.17-beta is interpreted like this: |
|    |The first number (3) describes the file format. All version 3 releases have the same  |
|    |file format. When a version 4 appears, every table will have to be converted to the   |
|    |new format (nice tools for this will be included, of course).                         |
|    |The second number (21) is the release level. Normally there are two to choose from.   |
|    |One is the release/stable branch (currently 21) and the other is the development      |
|    |branch (currently 22) . Normally both are stable, but the development version may have|
|    |quirks, missing documentation on new features or may fail to compile on some systems. |
|    |The third number (17) is the version number within the release level. This is         |
|    |incremented for each new distribution. Usually you want the latest version for the    |
|    |release level you have choosen.                                                       |
|    |The suffix (beta) indicates the stability level of the release. The possible suffixes |
|    |are:                                                                                  |
|    |alpha indicates that the release contains some large section of new code that hasn't  |
|    |been 100% tested. Known bugs (usually there are none) should be documented in the News|
|    |section. D Historique des versions de MySQL. There are also new commands and          |
|    |extensions in most alpha releases.                                                    |
|    |beta means that all new code has been tested. No major new features were added. There |
|    |should be no known bugs.                                                              |
|    |gamma is a beta that has been around a while and seems to work fine. This is what many|
|    |other companies call a release.                                                       |
|    |If there is no suffix, it means that the version has been run for a while at many     |
|    |different sites with no reports of bugs other than platform-specific bugs. This is    |
|    |what we call a stable release.                                                        |
|    |All versions of MySQL are run through our standard tests and benchmarks to ensure that|
|    |they are relatively safe to use. Since the standard tests are extended over time to   |
|    |check for all previously found bugs, the test suite keeps getting better.             |
|    |Note that all releases have been tested at least with:                                |
|    |An internal test suite                                                                |
|    |This is part of a production system for a customer. It has many tables with hundreds  |
|    |of megabytes of data.                                                                 |
|    |The MySQL benchmark suite                                                             |
|    |This runs a range of common queries. It is also a test to see whether the latest batch|
|    |of optimizations actually made the code faster. 11 La suite de tests de MySQL.        |
|    |The crash-me test                                                                     |
|    |This tries to determine what features the database supports and what its capabilities |
|    |and limitations are. 11 La suite de tests de MySQL.                                   |
|    |Another test is that we use the newest MySQL version in our internal production       |
|    |environment, on at least one machine. We have more than 100 gigabytes of data to work |
|    |with.                                                                                 |
|    |4.4 Comment et quand sont générées les mises à jour                                   |
|    |MySQL is evolving quite rapidly here at TcX and we want to share this with other MySQL|
|    |users. We try to make a release when we have very useful features that others seem to |
|    |have a need for.                                                                      |
|    |We also try to help out users who request features that are easy to implement. We also|
|    |take note of what our licensed users want to have and we especially take note of what |
|    |our extended email supported customers want and try to help them out.                 |
|    |No one has to download a new release. The News section will tell you if the new       |
|    |release has something you really want. D Historique des versions de MySQL.            |
|    |We use the following policy when updating MySQL:                                      |
|    |For each minor update, the last number in the version string is incremented. When     |
|    |there are major new features or minor incompatibilities with previous versions, the   |
|    |second number in the version string is incremented. When the file format changes, the |
|    |first number is increased.                                                            |
|    |Stable tested releases are meant to appear about 1-2 times a year, but if small bugs  |
|    |are found, a release with only bug-fixes will be released.                            |
|    |Working releases are meant to appear about every 1-8 weeks.                           |
|    |Binary distributions for some platforms will be made by us for major releases. Other  |
|    |people may make binary distributions for other systems but probably less frequently.  |
|    |We usually make patches available as soon as we have located and fixed small bugs.    |
|    |For non-critical but annoying bugs, we will make patches available if they are sent to|
|    |us. Otherwise we will combine many of them into a larger patch.                       |
|    |If there is, by any chance, a fatal bug in a release we will make a new release as    |
|    |soon as possible. We would like other companies to do this, too. :)                   |
|    |The current stable release is 3.22; We have already moved active development to 3.23. |
|    |Bugs will still be fixed in the stable version. We don't believe in a complete freeze,|
|    |as this also leaves out bug fixes and things that ``must be done''. ``Somewhat        |
|    |frozen'' means that we may add small things that ``almost surely will not affect      |
|    |anything that's already working''.                                                    |
|    |4.5 Structure de l'installation                                                       |
|    |This section describes the default layout of the directories created by installing    |
|    |binary and source distributions.                                                      |
|    |A binary distribution is installed by unpacking it at the installation location you   |
|    |choose (typically `/usr/local/mysql') and creates the following directories in that   |
|    |location:                                                                             |
|    |Directory                                                                             |
|    |Contents of directory                                                                 |
|    |                                                                                      |
|    |`bin'                                                                                 |
|    |Client programs and the mysqld server                                                 |
|    |                                                                                      |
|    |`data'                                                                                |
|    |Log files, databases                                                                  |
|    |                                                                                      |
|    |`include'                                                                             |
|    |Include (header) files                                                                |
|    |                                                                                      |
|    |`lib'                                                                                 |
|    |Libraries                                                                             |
|    |                                                                                      |
|    |`scripts'                                                                             |
|    |mysql_install_db                                                                      |
|    |                                                                                      |
|    |`share/mysql'                                                                         |
|    |Error message files                                                                   |
|    |                                                                                      |
|    |`sql-bench'                                                                           |
|    |Benchmarks                                                                            |
|    |                                                                                      |
|    |A source distribution is installed after you configure and compile it. By default, the|
|    |installation step installs files under `/usr/local', in the following subdirectories: |
|    |Directory                                                                             |
|    |Contents of directory                                                                 |
|    |                                                                                      |
|    |`bin'                                                                                 |
|    |Client programs and scripts                                                           |
|    |                                                                                      |
|    |`include/mysql'                                                                       |
|    |Include (header) files                                                                |
|    |                                                                                      |
|    |`info'                                                                                |
|    |Documentation in Info format                                                          |
|    |                                                                                      |
|    |`lib/mysql'                                                                           |
|    |Libraries                                                                             |
|    |                                                                                      |
|    |`libexec'                                                                             |
|    |The mysqld server                                                                     |
|    |                                                                                      |
|    |`share/mysql'                                                                         |
|    |Error message files                                                                   |
|    |                                                                                      |
|    |`sql-bench'                                                                           |
|    |Benchmarks and crash-me test                                                          |
|    |                                                                                      |
|    |`var'                                                                                 |
|    |Databases and log files.                                                              |
|    |                                                                                      |
|    |Within an installation directory, the layout of a source installation differs from    |
|    |that of a binary installation in the following ways:                                  |
|    |The mysqld server is installed in the `libexec' directory rather than in the `bin'    |
|    |directory.                                                                            |
|    |The data directory is `var' rather than `data'.                                       |
|    |mysql_install_db is installed in the `/usr/local/bin' directory rather than in        |
|    |`/usr/local/mysql/scripts'.                                                           |
|    |The header file and library directories are `include/mysql' and `lib/mysql' rather    |
|    |than `include' and `lib'.                                                             |
|    |4.6 Installer une version binaire de MySQL                                            |
|    |You need the following tools to install a MySQL binary distribution:                  |
|    |GNU gunzip to uncompress the distribution.                                            |
|    |A reasonable tar to unpack the distribution. GNU tar is known to work.                |
|    |An alternative installation méthode under Linux is to use RPM (RedHat Package Manager)|
|    |distributions. 4.6.1 Linux RPM.                                                       |
|    |If you run into problems, PLEASE ALWAYS USE mysqlbug when posting questions to        |
|    |[e-mail]. Even if the problem isn't a bug, mysqlbug gathers system       |
|    |information that will help others solve your problem. By not using mysqlbug, you      |
|    |lessen the likelihood of getting a solution to your problem! You will find mysqlbug in|
|    |the `bin' directory after you unpack the distribution. 2.3 Comment rapporter des bugs |
|    |et des problèmes.                                                                     |
|    |The basic commands you must execute to install and use a MySQL binary distribution    |
|    |are:                                                                                  |
|    |                                                                                      |
|    |shell> gunzip < mysql-VERSION-OS.tar.gz | tar xvf -                                   |
|    |shell> ln -s mysql-VERSION-OS mysql                                                   |
|    |shell> cd mysql                                                                       |
|    |shell> scripts/mysql_install_db                                                       |
|    |shell> bin/safe_mysqld &                                                              |
|    |You can add new users using the bin/mysql_setpermission script if you install the DBI |
|    |and Msql-Mysql-modules Perl modules.                                                  |
|    |Here follows a more detailed description:                                             |
|    |To install a binary distribution, follow the steps below, then proceed to 4.15        |
|    |Paramètrage post-installation et tests, for post-installation setup and testing:      |
|    |Pick the directory under which you want to unpack the distribution, and move into it. |
|    |In the example below, we unpack the distribution under `/usr/local' and create a      |
|    |directory `/usr/local/mysql' into which MySQL is installed. (The following            |
|    |instructions therefore assume you have permission to create files in `/usr/local'. If |
|    |that directory is protected, you will need to perform the installation as root.)      |
|    |Obtain a distribution file from one of the sites listed in Getting MySQL. MySQL binary|
|    |distributions are provided as compressed tar archives and have names like             |
|    |`mysql-VERSION-OS.tar.gz', where VERSION is a number (e.g., 3.21.15), and OS indicates|
|    |the type of operating system for which the distribution is intended (e.g.,            |
|    |pc-linux-gnu-i586).                                                                   |
|    |Unpack the distribution and create the installation directory:                        |
|    |                                                                                      |
|    |shell> gunzip < mysql-VERSION-OS.tar.gz | tar xvf -                                   |
|    |shell> ln -s mysql-VERSION-OS mysql                                                   |
|    |The first command creates a directory named `mysql-VERSION-OS'. The second command    |
|    |makes a symbolic link to that directory. This lets you refer more easily to the       |
|    |installation directory as `/usr/local/mysql'.                                         |
|    |Change into the installation directory:                                               |
|    |                                                                                      |
|    |shell> cd mysql                                                                       |
|    |You will find several files and subdirectories in the mysql directory. The most       |
|    |important for installation purposes are the `bin' and `scripts' subdirectories.       |
|    |`bin'                                                                                 |
|    |This directory contains client programs and the server You should add the full        |
|    |pathname of this directory to your PATH environment variable so that your shell finds |
|    |the MySQL programs properly.                                                          |
|    |`scripts'                                                                             |
|    |This directory contains the mysql_install_db script used to initialize the server     |
|    |access permissions.                                                                   |
|    |If you would like to use mysqlaccess and have the MySQL distribution in some          |
|    |nonstandard place, you must change the location where mysqlaccess expects to find the |
|    |mysql client. Edit the `bin/mysqlaccess' script at approximately line 18. Search for a|
|    |line that looks like this:                                                            |
|    |                                                                                      |
|    |$MYSQL     = '/usr/local/bin/mysql';    # path to mysql executable                    |
|    |Change the path to reflect the location where mysql actually is stored on your system.|
|    |If you do not do this, you will get a broken pipe error when you run mysqlaccess.     |
|    |Create the MySQL grant tables (necessary only if you haven't installed MySQL before): |
|    |                                                                                      |
|    |shell> scripts/mysql_install_db                                                       |
|    |If you want to install support for the Perl DBI/DBD interface, see 4.10 Remarques sur |
|    |l'installation Perl.                                                                  |
|    |If you would like MySQL to start automatically when you boot your machine, you can    |
|    |copy support-files/mysql.server to the location where your system has its startup     |
|    |files. More information can be found in the support-files/mysql.server script itself, |
|    |and in 4.15.3 Démarrer et arrête MySQL automatiquement.                               |
|    |After everything has been unpacked and installed, you should initialize and test your |
|    |distribution.                                                                         |
|    |You can start the MySQL server with the following command:                            |
|    |                                                                                      |
|    |shell> bin/safe_mysqld &                                                              |
|    |Note that MySQL versions older than 3.22.10 started the MySQL server when you run     |
|    |mysql_install_db. This is no longer true!                                             |
|    |4.15 Paramètrage post-installation et tests.                                          |
|    |4.6.1 Linux RPM                                                                       |
|    |The recommended way to install MySQL on Linux is by using an RPM file. The MySQL RPMs |
|    |are currently being built on a RedHat 5.2 system but should work on other versions of |
|    |Linux that support rpm and use glibc.                                                 |
|    |If you have problems with an RPM file, for example Sorry, the host 'xxxx' could not be|
|    |looked up, see 4.6.3.1 Linux notes.                                                   |
|    |The RPM files you may want to use are:                                                |
|    |MySQL-VERSION.i386.rpm The MySQL server. You will need this unless you only want to   |
|    |connect to another MySQL server running on another machine.                           |
|    |MySQL-client-VERSION.i386.rpm The standard MySQL client programs. You probably always |
|    |want to install this package.                                                         |
|    |MySQL-bench-VERSION.i386.rpm Tests and benchmarks. Requires Perl and                  |
|    |msql-mysql-modules RPMs.                                                              |
|    |MySQL-devel-VERSION.i386.rpm Libraries and include files needed if you want to compile|
|    |other MySQL clients, such as the Perl modules.                                        |
|    |MySQL-VERSION.src.rpm This contains the source code for all of the above packages. It |
|    |can also be used to try to build RPMs for other architectures (for example, Alpha or  |
|    |SPARC).                                                                               |
|    |To see all files in an RPM package:                                                   |
|    |                                                                                      |
|    |shell> rpm -qpl MySQL-VERSION.i386.rpm                                                |
|    |To perform a standard minimal installation, run this command:                         |
|    |                                                                                      |
|    |shell> rpm -i MySQL-VERSION.i386.rpm MySQL-client-VERSION.i386.rpm                    |
|    |To install just the client package:                                                   |
|    |                                                                                      |
|    |shell> rpm -i MySQL-client-VERSION.i386.rpm                                           |
|    |The RPM places data in `/var/lib/mysql'. The RPM also creates the appropriate entries |
|    |in `/sbin/rc.d/' to start the server automatically at boot time. (This means that if  |
|    |you have performed a previous installation, you may want to make a copy of your       |
|    |previously-installed MySQL startup file if you made any changes to it, so you don't   |
|    |lose your changes.)                                                                   |
|    |After installing the RPM file(s), go to the binary install section and use the        |
|    |instructions there, starting from the step that creates the MySQL grant tables. 4.6   |
|    |Installer une version binaire de MySQL.                                               |
|    |4.6.2 Construire un programme client                                                  |
|    |If you compile MySQL clients that you've written yourself or that you obtain from a   |
|    |third party, they must be linked using the -lmysqlclient option on the link command.  |
|    |You may also need to specify a -L option to tell the linker where to find the library.|
|    |For example, if the library is installed in `/usr/local/mysql/lib', use               |
|    |-L/usr/local/mysql/lib -lmysqlclient on the link command.                             |
|    |For clients that use MySQL header files, you may need to specify a -I option when you |
|    |compile them (for example, -I/usr/local/mysql/include), so the compiler can find the  |
|    |header files.                                                                         |
|    |4.6.3 Instruction spécifiques aux OS                                                  |
|    |The following sections indicate some of the issues that have been observed to occur on|
|    |particular systems when installing MySQL from a binary distribution.                  |
|    |4.6.3.1 Linux notes                                                                   |
|    |MySQL needs at least Linux 2.0.                                                       |
|    |The binary release is linked with -static, which means you not normally need not worry|
|    |about which version of the system libraries you have. You need not install            |
|    |LinuxThreads, either. A program linked with -static is slightly bigger than a         |
|    |dynamically-linked program but also slightly faster (3-5%). One problem however is    |
|    |that you can't use user definable functions (UDFs) with a statically-linked program.  |
|    |If you are going to write or use UDF functions (this is something only for C or C++   |
|    |programmers) you must compile MySQL yourself, using dynamic linking.                  |
|    |If you are using a libc-based system (instead of a glibc2 system), you will probably  |
|    |get some problems with hostname resolving and getpwnam() with the binary release.     |
|    |(This is because glibc unfortunately depends on some external libraries to resolve    |
|    |hostnames and getwpent() , even when compiled with -static). In this case you probably|
|    |get the following error message when you run mysql_install_db:                        |
|    |                                                                                      |
|    |Sorry, the host 'xxxx' could not be looked up                                         |
|    |or the following error when you try to run mysqld with the --user option:             |
|    |                                                                                      |
|    |getpwnam: No such file or directory                                                   |
|    |You can solve this problem one of the following ways:                                 |
|    |Get a MySQL source distribution (an RPM or the tar distribution) and install this     |
|    |instead.                                                                              |
|    |Execute mysql_install_db --force; This will not execute the resolveip test in         |
|    |mysql_install_db. The downside is that you can't use host names in the grant tables;  |
|    |you must use IP numbers instead (except for localhost). If you are using an old MySQL |
|    |release that doesn't support --force you have to remove the resolveip test in         |
|    |mysql_install with an editor.                                                         |
|    |Start mysqld with su instead of using --user.                                         |
|    |The Linux-Intel binary and RPM releases of MySQL are configured for the highest       |
|    |possible speed. We are always trying to use the fastest stable compiler available.    |
|    |MySQL Perl support requires Perl 5.004_03 or newer.                                   |
|    |4.6.3.2 HP-UX notes                                                                   |
|    |The binary distribution of MySQL for HP-UX is distributed as an HP depot file and as a|
|    |tar file. To use the depot file you must be running at least HP-UX 10.x to have access|
|    |to HP's software depot tools.                                                         |
|    |The HP version of MySQL was compiled on an HP 9000/8xx server under HP-UX 10.20, and  |
|    |uses MIT-pthreads. It is known to work well under this configuration. MySQL 3.22.26   |
|    |and newer can also be built with HP's native thread package.                          |
|    |Other configurations that may work:                                                   |
|    |HP 9000/7xx running HP-UX 10.20+                                                      |
|    |HP 9000/8xx running HP-UX 10.30                                                       |
|    |The following configurations almost definitely won't work:                            |
|    |HP 9000/7xx or 8xx running HP-UX 10.x where x < 2                                     |
|    |HP 9000/7xx or 8xx running HP-UX 9.x                                                  |
|    |To install the distribution, use one of the commands below, where /path/to/depot is   |
|    |the full pathname of the depot file:                                                  |
|    |To install everything, including the server, client and development tools:            |
|    |                                                                                      |
|    |shell> /usr/sbin/swinstall -s /path/to/depot mysql.full                               |
|    |To install only the server:                                                           |
|    |                                                                                      |
|    |shell> /usr/sbin/swinstall -s /path/to/depot mysql.server                             |
|    |To install only the client package:                                                   |
|    |                                                                                      |
|    |shell> /usr/sbin/swinstall -s /path/to/depot mysql.client                             |
|    |To install only the development tools:                                                |
|    |                                                                                      |
|    |shell> /usr/sbin/swinstall -s /path/to/depot mysql.developer                          |
|    |The depot places binaries and libraries in `/opt/mysql' and data in `/var/opt/mysql'. |
|    |The depot also creates the appropriate entries in `/sbin/init.d' and `/sbin/rc2.d' to |
|    |start the server automatically at boot time. Obviously, this entails being root to    |
|    |install.                                                                              |
|    |To install the HP-UX tar distribution, you must have a copy of gnu tar.               |
|    |4.7 Installer une version source de MySQL                                             |
|    |You need the following tools to build and install MySQL from source:                  |
|    |GNU gunzip to uncompress the distribution.                                            |
|    |A reasonable tar to unpack the distribution. GNU tar is known to work.                |
|    |A working ANSI C++ compiler. gcc >= 2.8.1, egcs >= 1.0.2, SGI C++ and SunPro C++ are  |
|    |some of the compilers that are known to work. libg++ is not needed when using gcc. gcc|
|    |2.7.x has a bug that makes it impossible to compile some perfectly legal C++ files,   |
|    |such as `sql/sql_base.cc'. If you only have gcc 2.7.x, you must upgrade your gcc to be|
|    |able to compile MySQL.                                                                |
|    |A good make program. GNU make is always recommended and is sometimes required. If you |
|    |have problems, we recommend trying GNU make 3.75 or newer.                            |
|    |If you run into problems, PLEASE ALWAYS USE mysqlbug when posting questions to        |
|    |[e-mail]. Even if the problem isn't a bug, mysqlbug gathers system       |
|    |information that will help others solve your problem. By not using mysqlbug, you      |
|    |lessen the likelihood of getting a solution to your problem! You will find mysqlbug in|
|    |the `scripts' directory after you unpack the distribution. 2.3 Comment rapporter des  |
|    |bugs et des problèmes.                                                                |
|    |4.7.1 Introduction à l'installation rapide                                            |
|    |The basic commands you must execute to install a MySQL source distribution are (from  |
|    |an unpacked tar file):                                                                |
|    |                                                                                      |
|    |shell> configure                                                                      |
|    |shell> make                                                                           |
|    |shell> make install                                                                   |
|    |shell> scripts/mysql_install_db                                                       |
|    |shell> /usr/local/mysql/bin/safe_mysqld &                                             |
|    |If you start from a source RPM, then do the following.                                |
|    |                                                                                      |
|    |shell> rpm --rebuild MySQL-VERSION.src.rpm                                            |
|    |This will make a binary RPM that you can install.                                     |
|    |You can add new users using the bin/mysql_setpermission script if you install the DBI |
|    |and Msql-Mysql-modules Perl modules.                                                  |
|    |Here follows a more detailed description:                                             |
|    |To install a source distribution, follow the steps below, then proceed to 4.15        |
|    |Paramètrage post-installation et tests, for post-installation initialization and      |
|    |testing.                                                                              |
|    |Pick the directory under which you want to unpack the distribution, and move into it. |
|    |Obtain a distribution file from one of the sites listed in Getting MySQL. MySQL source|
|    |distributions are provided as compressed tar archives and have names like             |
|    |`mysql-VERSION.tar.gz', where VERSION is a number like .                              |
|    |Unpack the distribution into the current directory:                                   |
|    |                                                                                      |
|    |shell> gunzip < mysql-VERSION.tar.gz | tar xvf -                                      |
|    |This command creates a directory named `mysql-VERSION'.                               |
|    |Change into the top-level directory of the unpacked distribution:                     |
|    |                                                                                      |
|    |shell> cd mysql-VERSION                                                               |
|    |Configure the release and compile everything:                                         |
|    |                                                                                      |
|    |shell> ./configure --prefix=/usr/local/mysql                                          |
|    |shell> make                                                                           |
|    |When you run configure, you might want to specify some options. Run ./configure --help|
|    |for a list of options. configure options, discusses some of the more useful options.  |
|    |If configure fails, and you are going to send mail to lines from `config.log' that you|
|    |think can help solve the problem. Also include the last couple of lines of output from|
|    |configure if configure aborts. Post the bug report using the mysqlbug script. 2.3     |
|    |Comment rapporter des bugs et des problèmes. If the compile fails, see 4.8 Problèmes  |
|    |de compilation?, for help with a number of common problems.                           |
|    |Install everything:                                                                   |
|    |                                                                                      |
|    |shell> make install                                                                   |
|    |You might need to run this command as root.                                           |
|    |Create the MySQL grant tables (necessary only if you haven't installed MySQL before): |
|    |                                                                                      |
|    |shell> scripts/mysql_install_db                                                       |
|    |Note that MySQL versions older than 3.22.10 started the MySQL server when you run     |
|    |mysql_install_db. This is no longer true!                                             |
|    |If you want to install support for the Perl DBI/DBD interface, see 4.10 Remarques sur |
|    |l'installation Perl.                                                                  |
|    |If you would like MySQL to start automatically when you boot your machine, you can    |
|    |copy support-files/mysql.server to the location where your system has its startup     |
|    |files. More information can be found in the support-files/mysql.server script itself, |
|    |and in 4.15.3 Démarrer et arrête MySQL automatiquement.                               |
|    |After everything has been installed, you should initialize and test your distribution.|
|    |                                                                                      |
|    |You can start the MySQL server with the following command, where BINDIR is the        |
|    |directory in which safe_mysqld is installed (`/usr/local/bin' by default):            |
|    |                                                                                      |
|    |shell> BINDIR/safe_mysqld &                                                           |
|    |If that command fails immediately with mysqld daemon ended then you can find some     |
|    |information in the file `mysql-data-directory/'hostname'.err'. The likely reason is   |
|    |that you already have another mysqld server running. 19.3 Faire tourner plusieurs     |
|    |serveurs MySQL sur la même machine.                                                   |
|    |4.15 Paramètrage post-installation et tests.                                          |
|    |4.7.2 Appliquer un patch                                                              |
|    |Sometimes patches appear on the mailing list or are placed in the patches area of the |
|    |MySQL FTP site.                                                                       |
|    |To apply a patch from the mailing list, save the message in which the patch appears in|
|    |a file, change into the top-level directory of your MySQL source tree and run these   |
|    |commands:                                                                             |
|    |                                                                                      |
|    |shell> patch -p1 < patch-file-name                                                    |
|    |shell> rm config.cache                                                                |
|    |shell> make clean                                                                     |
|    |Patches from the FTP site are distributed as plain text files or as files compressed  |
|    |with gzip files. Apply a plain patch as shown above for mailing list patches. To apply|
|    |a compressed patch, change into the top-level directory of your MySQL source tree and |
|    |run these commands:                                                                   |
|    |                                                                                      |
|    |shell> gunzip < patch-file-name.gz | patch -p1                                        |
|    |shell> rm config.cache                                                                |
|    |shell> make clean                                                                     |
|    |After applying a patch, follow the instructions for a normal source install, beginning|
|    |with the ./configure step. After running the make install step, restart your MySQL    |
|    |server.                                                                               |
|    |You may need to bring down any currently running server before you run make install.  |
|    |(Use mysqladmin shutdown to do this.) Some systems do not allow you to install a new  |
|    |version of a program if it replaces the version that is currently executing.          |
|    |4.7.3 Options communes de configure                                                   |
|    |The configure script gives you a great deal of control over how you configure your    |
|    |MySQL distribution. Typically you do this using options on the configure command line.|
|    |You can also affect configure using certain environment variables. For a list of      |
|    |options supported by configure, run this command:                                     |
|    |                                                                                      |
|    |shell> ./configure --help                                                             |
|    |Some of the more commonly-used configure options are described below:                 |
|    |To compile just the MySQL client libraries and client programs and not the server, use|
|    |the --without-server option:                                                          |
|    |                                                                                      |
|    |shell> ./configure --without-server                                                   |
|    |If you don't have a C++ compiler, mysql will not compile (it is the one client program|
|    |that requires C++). In this case, you can remove the code in configure that tests for |
|    |the C++ compiler and then run ./configure with the --without-server option. The       |
|    |compile step will still try to build mysql, but you can ignore any warnings about     |
|    |`mysql.cc'. (If make stops, try make -k to tell it to continue with the rest of the   |
|    |build even if errors occur.)                                                          |
|    |If you don't want your log files and database directories located under               |
|    |`/usr/local/var', use a configure command something like one of these:                |
|    |                                                                                      |
|    |shell> ./configure --prefix=/usr/local/mysql                                          |
|    |shell> ./configure --prefix=/usr/local \                                              |
|    |--localstatedir=/usr/local/mysql/data                                                 |
|    |The first command changes the installation prefix so that everything is installed     |
|    |under `/usr/local/mysql' rather than the default of `/usr/local'. The second command  |
|    |preserves the default installation prefix, but overrides the default location for     |
|    |database directories (normally `/usr/local/var') and changes it to                    |
|    |/usr/local/mysql/data.                                                                |
|    |If you are using Unix and you want the MySQL socket located somewhere other than the  |
|    |default location (normally in the directory `/tmp' or `/var/run', use a configure     |
|    |command like this:                                                                    |
|    |                                                                                      |
|    |shell> ./configure --with-unix-socket-path=/usr/local/mysql/tmp/mysql.sock            |
|    |Note that the given file must be an absolute pathname!                                |
|    |If you want to compile statically-linked programs (e.g., to make a binary             |
|    |distribution, to get more speed or to work around problems with some RedHat           |
|    |distributions), run configure like this:                                              |
|    |                                                                                      |
|    |shell> ./configure --with-client-ldflags=-all-static \                                |
|    |--with-mysqld-ldflags=-all-static                                                     |
|    |If you are using gcc and don't have libg++ or libstdc++ installed, you can tell       |
|    |configure to use gcc as your C++ compiler:                                            |
|    |                                                                                      |
|    |shell> CC=gcc CXX=gcc ./configure                                                     |
|    |When you use gcc as your C++ compiler, it will not attempt to link in libg++ or       |
|    |libstdc++. If the build fails and produces errors about your compiler or linker not   |
|    |being able to create the shared library `libmysqlclient.so.#' (`#' is a version       |
|    |number), you can work around this problem by giving the --disable-shared option to    |
|    |configure. In this case, configure will not build a shared libmysqlclient.so.#        |
|    |library.                                                                              |
|    |You can configure MySQL not to use DEFAULT column values for non-NULL columns (i.e.,  |
|    |columns that are not allowed to be NULL). This causes INSERT statements to generate an|
|    |error unless you explicitly specify values for all columns that require a non-NULL    |
|    |value. To suppress use of default values, run configure like this:                    |
|    |                                                                                      |
|    |shell> CXXFLAGS=-DDONT_USE_DEFAULT_FIELDS ./configure                                 |
|    |By default, MySQL uses the ISO-8859-1 (Latin1) character set. To change the default   |
|    |set, use the --with-charset option:                                                   |
|    |                                                                                      |
|    |shell> ./configure --with-charset=CHARSET                                             |
|    |CHARSET may be one of big5, cp1251, cp1257, czech, danish,dec8, dos, euc_kr, german1, |
|    |hebrew, hp8, hungarian, koi8_ru, koi8_ukr, latin1, latin2, sjis, swe7, tis620, ujis,  |
|    |usa7, win1251 or win1251ukr. 9.1.1 Le jeu de caractère utilisé pour le tri des        |
|    |données. Note that if you want to change the character set, you must do a make        |
|    |distclean between configurations! If you want to convert characters between the server|
|    |and the client, you should take a look at the SET OPTION CHARACTER SET command. SET   |
|    |OPTION. Warning: If you change character sets after having created any tables, you    |
|    |will have to run isamchk -r -q on every table. Your indexes may be sorted incorrectly |
|    |otherwise. (This can happen if you install MySQL, create some tables, then reconfigure|
|    |MySQL to use a different character set and reinstall it.)                             |
|    |To configure MySQL with debugging code, use the --with-debug option:                  |
|    |                                                                                      |
|    |shell> ./configure --with-debug                                                       |
|    |This causes a safe memory allocator to be included that can find some errors and that |
|    |provides output about what is happening. G.1 Debugguer un serveur MySQL.              |
|    |Options that pertain to particular systems can be found in the system-specific        |
|    |sections later in this chapter. 4.11 Quelques spécificités liées aux OS.              |
|    |4.8 Problèmes de compilation?                                                         |
|    |All MySQL programs compile cleanly for us with no warnings on Solaris using gcc. On   |
|    |other systems, warnings may occur due to differences in system include files. See 4.9 |
|    |Remarques sur MIT-pthreads, for warnings that may occur when using MIT-pthreads. For  |
|    |other problems, check the list below.                                                 |
|    |The solution to many problems involves reconfiguring. If you do need to reconfigure,  |
|    |take note of the following:                                                           |
|    |If configure is run after it already has been run, it may use information that was    |
|    |gathered during its previous invocation. This information is stored in `config.cache'.|
|    |When configure starts up, it looks for that file and reads its contents if it exists, |
|    |on the assumption that the information is still correct. That assumption is invalid   |
|    |when you reconfigure.                                                                 |
|    |Each time you run configure, you must run make again to recompile. However, you may   |
|    |want to remove old object files from previous builds first, since they were compiled  |
|    |using different configuration options.                                                |
|    |To prevent old configuration information or object files from being used, run these   |
|    |commands before rerunning configure:                                                  |
|    |                                                                                      |
|    |shell> rm config.cache                                                                |
|    |shell> make clean                                                                     |
|    |Alternatively, you can run make distclean.                                            |
|    |The list below describes some of the problems compiling MySQL that have been found to |
|    |occur most often:                                                                     |
|    |If you get errors when compiling `sql_yacc.cc' such as the ones shown below, you have |
|    |probably run out of memory or swap space:                                             |
|    |                                                                                      |
|    |Internal compiler error: program cc1plus got fatal signal 11                          |
|    |or                                                                                    |
|    |Out of virtual memory                                                                 |
|    |or                                                                                    |
|    |Virtual memory exhausted                                                              |
|    |The problem is that gcc requires huge amounts of memory to compile `sql_yacc.cc' with |
|    |inline functions. Try running configure with the --with-low-memory option:            |
|    |                                                                                      |
|    |shell> ./configure --with-low-memory                                                  |
|    |This option causes -fno-inline to be added to the compile line if you are using gcc   |
|    |and -O0 if you are using something else. You should try the --with-low-memory option  |
|    |even if you have so much memory and swap space that you think you can't possibly have |
|    |run out. This problem has been observed to occur even on systems with generous        |
|    |hardware configurations, and the --with-low-memory option usually fixes it.           |
|    |By default, configure picks c++ as the compiler name and GNU c++ links with -lg++. If |
|    |you are using gcc, that behavior can cause problems during configuration such as this:|
|    |                                                                                      |
|    |                                                                                      |
|    |configure: error: installation or configuration problem:                              |
|    |C++ compiler cannot create executables.                                               |
|    |You might also observe problems during compilation related to g++, libg++ or          |
|    |libstdc++. One cause of these problems is that you may not have g++, or you may have  |
|    |g++ but not libg++ or libstdc++. Take a look at the `config.log' file. It should      |
|    |contain the exact reason why your c++ compiler didn't work! To work around these      |
|    |problems, you can use gcc as your C++ compiler. Try setting the environment variable  |
|    |CXX to "gcc -O3". For example:                                                        |
|    |                                                                                      |
|    |shell> CXX="gcc -O3" ./configure                                                      |
|    |This works because gcc compiles C++ sources as well as g++ does, but does not link in |
|    |libg++ or libstdc++ by default. Another way to fix these problems, of course, is to   |
|    |install g++, libg++ and libstdc++.                                                    |
|    |If your compile fails with errors such as any of the following, you must upgrade your |
|    |version of make to GNU make:                                                          |
|    |                                                                                      |
|    |making all in mit-pthreads                                                            |
|    |make: Fatal error in reader: Makefile, line 18:                                       |
|    |Badly formed macro assignment                                                         |
|    |or                                                                                    |
|    |make: file `Makefile' line 18: Must be a separator (:                                 |
|    |or                                                                                    |
|    |pthread.h: No such file or directory                                                  |
|    |Solaris and FreeBSD are known to have troublesome make programs. GNU make version 3.75|
|    |is known to work.                                                                     |
|    |If you want to define flags to be used by your C or C++ compilers, do so by adding the|
|    |flags to the CFLAGS and CXXFLAGS environment variables. You can also specify the      |
|    |compiler names this way using CC and CXX. For example:                                |
|    |                                                                                      |
|    |shell> CC=gcc                                                                         |
|    |shell> CFLAGS=-O6                                                                     |
|    |shell> CXX=gcc                                                                        |
|    |shell> CXXFLAGS=-O6                                                                   |
|    |shell> export CC CFLAGS CXX CXXFLAGS                                                  |
|    |See 4.14 TcX, for a list of flag definitions that have been found to be useful on     |
|    |various systems.                                                                      |
|    |If you get an error message like this, you need to upgrade your gcc compiler:         |
|    |                                                                                      |
|    |client/libmysql.c:273: parse error before `__attribute__'                             |
|    |gcc 2.8.1 is known to work, but we recommend using egcs 1.0.3a or newer instead.      |
|    |If you get errors such as those shown below when compiling mysqld, configure didn't   |
|    |correctly detect the type of the last argument to accept(), getsockname() or          |
|    |getpeername():                                                                        |
|    |                                                                                      |
|    |cxx: Error: mysqld.cc, line 645: In this statement, the referenced                    |
|    |type of the pointer value "&length" is "unsigned long", which                         |
|    |is not compatible with "int".                                                         |
|    |new_sock = accept(sock, (struct sockaddr *)&cAddr, &length);                          |
|    |To fix this, edit the `config.h' file (which is generated by configure). Look for     |
|    |these lines:                                                                          |
|    |                                                                                      |
|    |/* Define as the base type of the last arg to accept */                               |
|    |#define SOCKET_SIZE_TYPE XXX                                                          |
|    |Change XXX to size_t or int, depending on your operating system. (Note that you will  |
|    |have to do this each time you run configure, since configure regenerates `config.h'.) |
|    |The `sql_yacc.cc' file is generated from `sql_yacc.yy'. Normally the build process    |
|    |doesn't need to create `sql_yacc.cc', because MySQL comes with an already-generated   |
|    |copy. However, if you do need to recreate it, you might encounter this error:         |
|    |                                                                                      |
|    |"sql_yacc.yy", line xxx fatal: default action causes potential...                     |
|    |This is a sign that your version of yacc is deficient. You probably need to install   |
|    |bison (the GNU version of yacc) and use that instead.                                 |
|    |If you need to debug mysqld or a MySQL client, run configure with the --with-debug    |
|    |option, then recompile and link your clients with the new client library. G.2         |
|    |Debugguer un client MySQL.                                                            |
|    |4.9 Remarques sur MIT-pthreads                                                        |
|    |This section describes some of the issues involved in using MIT-pthreads.             |
|    |Note that on Linux you should NOT use MIT-pthreads but install LinuxThreads! 4.11.5   |
|    |Linux (Toutes versions de Linux).                                                     |
|    |If your system does not provide native thread support, you will need to build MySQL   |
|    |using the MIT-pthreads package. This includes most FreeBSD systems, SunOS 4.x, Solaris|
|    |2.4 and earlier, and some others. 4.2 Systèmes d'exploitation supportés par MySQL.    |
|    |On most systems, you can force MIT-pthreads to be used by running configure with the  |
|    |--with-mit-threads option:                                                            |
|    |                                                                                      |
|    |shell> ./configure --with-mit-threads                                                 |
|    |Building in a non-source directory is not supported when using MIT-pthreads, because  |
|    |we want to minimize our changes to this code.                                         |
|    |MIT-pthreads doesn't support the AF_UNIX protocol used to implement Unix sockets. This|
|    |means that if you compile using MIT-pthreads, all connections must be made using      |
|    |TCP/IP (which is a little slower). If you find after building MySQL that you cannot   |
|    |connect to the local server, it may be that your client is attempting to connect to   |
|    |localhost using a Unix socket as the default. Try making a TCP/IP connection with     |
|    |mysql by using a host option (-h or --host) to specify the local host name explicitly.|
|    |                                                                                      |
|    |The checks that determine whether or not to use MIT-pthreads occur only during the    |
|    |part of the configuration process that deals with the server code. If you have        |
|    |configured the distribution using --without-server to build only the client code,     |
|    |clients will not know whether or not MIT-pthreads is being used and will use Unix     |
|    |socket connections by default. Since Unix sockets do not work under MIT-pthreads, this|
|    |means you will need to use -h or --host when you run client programs.                 |
|    |When MySQL is compiled using MIT-pthreads, system locking is disabled by default for  |
|    |performance reasons. You can tell the server to use system locking with the           |
|    |--use-locking option.                                                                 |
|    |Sometimes the pthread bind() command fails to bind to a socket without any error      |
|    |message (at least on Solaris). The result is that all connections to the server fail. |
|    |For example:                                                                          |
|    |                                                                                      |
|    |shell> mysqladmin version                                                             |
|    |mysqladmin: connect to server at '' failed;                                           |
|    |error: 'Can't connect to mysql server on localhost (146)'                             |
|    |The solution to this is to kill the mysqld server and restart it. This has only       |
|    |happened to us when we have forced the server down and done a restart immediately.    |
|    |With MIT-pthreads, the sleep() system call isn't interruptible with SIGINT (break).   |
|    |This is only noticeable when you run mysqladmin --sleep. You must wait for the sleep()|
|    |call to terminate before the interrupt is served and the process stops.               |
|    |When linking you may receive warning messages like these (at least on Solaris); they  |
|    |can be ignored:                                                                       |
|    |                                                                                      |
|    |ld: warning: symbol `_iob' has differing sizes:                                       |
|    |(file /my/local/pthreads/lib/libpthread.a(findfp.o) value=0x4;                        |
|    |file /usr/lib/libc.so value=0x140);                                                   |
|    |/my/local/pthreads/lib/libpthread.a(findfp.o) definition taken                        |
|    |ld: warning: symbol `__iob' has differing sizes:                                      |
|    |(file /my/local/pthreads/lib/libpthread.a(findfp.o) value=0x4;                        |
|    |file /usr/lib/libc.so value=0x140);                                                   |
|    |/my/local/pthreads/lib/libpthread.a(findfp.o) definition taken                        |
|    |Some other warnings also can be ignored:                                              |
|    |                                                                                      |
|    |implicit declaration of function `int strtoll(...)'                                   |
|    |implicit declaration of function `int strtoul(...)'                                   |
|    |We haven't gotten readline to work with MIT-pthreads. (This isn't needed, but may be  |
|    |interesting for someone.)                                                             |
|    |4.10 Remarques sur l'installation Perl                                                |
|    |4.10.1 Installer Perl sous Unix                                                       |
|    |Perl support for MySQL is provided by means of the DBI/DBD client interface. 20.5 API |
|    |MySQL en Perl. The Perl DBD/DBI client code requires Perl 5.004 or later. The         |
|    |interface will not work if you have an older version of Perl.                         |
|    |MySQL Perl support also requires that you've installed MySQL client programming       |
|    |support. If you installed MySQL from RPM files, client programs are in the client RPM,|
|    |but client programming support is in the developer RPM. Make sure you've installed the|
|    |latter RPM.                                                                           |
|    |As of release 3.22.8, Perl support is distributed separately from the main MySQL      |
|    |distribution. If you want to install Perl support, the files you will need can be     |
|    |obtained from http://www.mysql.com/Contrib.                                           |
|    |The Perl distributions are provided as compressed tar archives and have names like    |
|    |`MODULE-VERSION.tar.gz', where MODULE is the module name and VERSION is the version   |
|    |number. You should get the Data-Dumper, DBI, and Msql-Mysql-modules distributions and |
|    |install them in that order. The installation procedure is shown below. The example    |
|    |shown is for the Data-Dumper module, but the procedure is the same for all three      |
|    |distributions.                                                                        |
|    |Unpack the distribution into the current directory:                                   |
|    |                                                                                      |
|    |shell> gunzip < Data-Dumper-VERSION.tar.gz | tar xvf -                                |
|    |This command creates a directory named `Data-Dumper-VERSION'.                         |
|    |Change into the top-level directory of the unpacked distribution:                     |
|    |                                                                                      |
|    |shell> cd Data-Dumper-VERSION                                                         |
|    |Build the distribution and compile everything:                                        |
|    |                                                                                      |
|    |shell> perl Makefile.PL                                                               |
|    |shell> make                                                                           |
|    |shell> make test                                                                      |
|    |shell> make install                                                                   |
|    |The make test command is important, because it verifies that the module is working.   |
|    |Note that when you run that command during the Msql-Mysql-modules installation to     |
|    |exercise the interface code, the MySQL server must be running or the test will fail.  |
|    |It is a good idea to rebuild and reinstall the Msql-Mysql-modules distribution        |
|    |whenever you install a new release of MySQL, particularly if you notice symptoms such |
|    |as all your DBI scripts dumping core after you upgrade MySQL.                         |
|    |If you don't have the right to install Perl modules in the system directory or if you |
|    |to install local Perl modules, the following reference may help you:                  |
|    |                                                                                      |
|    |http://www.iserver.com/support/contrib/perl5/modules.html                             |
|    |Look under the heading Installing New Modules that Require Locally Installed Modules. |
|    |4.10.2 Installer ActiveState Perl sous Win32                                          |
|    |To install the MySQL DBD module with ActiveState Perl on Win32, you should do the     |
|    |following:                                                                            |
|    |Open a DOS shell.                                                                     |
|    |If required, set the HTTP_proxy variable. For example, you might try: set             |
|    |HTTP_proxy=my.proxy.com:3128                                                          |
|    |Start the PPM program: C:\perl\bin\ppm.pl                                             |
|    |If you have not already done so, install DBI: install DBI                             |
|    |If this succeeds, install DBD::mysql: http://www.mysql.com/Contrib/ppd/DBD-mysql.ppd  |
|    |If you can't get the above to work, you should instead install the MyODBC driver and  |
|    |connect to MySQL server through ODBC.                                                 |
|    |                                                                                      |
|    |use DBI;                                                                              |
|    |$dbh= DBI->connect("DBI:ODBC:$dsn","$user","$password") ||                            |
|    |die "Got error $DBI::errstr when connecting to $dsn\n";                               |
|    |4.10.3 Installer la distribution Perl de MySQL sous Win32                             |
|    |The MySQL Perl distribution contains DBI, DBD:MySQL and DBD:ODBC.                     |
|    |Get the Perl distribution for Win32 from http://www.mysql.com/download.html.          |
|    |Unzip the distribution in C: so that you get a `C:\PERL' directory.                   |
|    |Add the directory `C:\PERL\BIN' to your path.                                         |
|    |Add the directory `C:\PERL\BIN\MSWin32-x86-thread' or `C:\PERL\BIN\MSWin32-x86' to    |
|    |your path.                                                                            |
|    |Test that perl works by executing perl -v in a DOS shell.                             |
|    |4.10.4 Problèmes avec l'interface DBI/DBD de Perl                                     |
|    |If Perl reports that it can't find the ../mysql/mysql.so module, then the problem is  |
|    |probably that Perl can't locate the shared library `libmysqlclient.so'.               |
|    |You can fix this by any of the following méthodes:                                    |
|    |Compile the Msql-Mysql-modules distribution with perl Makefile.PL -static rather than |
|    |perl Makefile.PL                                                                      |
|    |Copy libmysqlclient.so to the directory where your other shared libraries are located |
|    |(probably `/usr/lib' or `/lib').                                                      |
|    |On Linux you can add the pathname of the directory where libmysqlclient.so is located |
|    |to the `/etc/ld.so.conf' file.                                                        |
|    |Add the pathname of the directory where libmysqlclient.so is located to the           |
|    |LD_RUN_PATH environment variable.                                                     |
|    |If you get the following errors from DBD-mysql, you are probably using gcc (or using  |
|    |an old binary compiled with gcc):                                                     |
|    |                                                                                      |
|    |/usr/bin/perl: can't resolve symbol '__moddi3'                                        |
|    |/usr/bin/perl: can't resolve symbol '__divdi3'                                        |
|    |Add -L/usr/lib/gcc-lib/... -lgcc to the link command when the `mysql.so' library gets |
|    |built (check the output from make for `mysql.so' when you compile the Perl client).   |
|    |The -L option should specify the pathname of the directory where `libgcc.a' is located|
|    |on your system.                                                                       |
|    |Another cause of this problem may be that Perl and MySQL aren't both compiled with    |
|    |gcc. In this case, you can solve the mismatch by compiling both with gcc.             |
|    |If you want to use the Perl module on a system that doesn't support dynamic linking   |
|    |(like SCO) you can generate a static version of Perl that includes DBI and DBD-mysql. |
|    |The way this works is that you generate a version of Perl with the DBI code linked in |
|    |and install it on top of your current Perl. Then you use that to build a version of   |
|    |Perl that additionally has the DBD code linked in, and install that.                  |
|    |On SCO, you must have the following environment variables set:                        |
|    |                                                                                      |
|    |shell> LD_LIBRARY_PATH=/lib:/usr/lib:/usr/local/lib:/usr/progressive/lib              |
|    |or                                                                                    |
|    |shell>                                                                                |
|    |LD_LIBRARY_PATH=/usr/lib:/lib:/usr/local/lib:/usr/ccs/lib:/usr/progressive/lib:/usr/sk|
|    |unk/lib                                                                               |
|    |shell>                                                                                |
|    |LIBPATH=/usr/lib:/lib:/usr/local/lib:/usr/ccs/lib:/usr/progressive/lib:/usr/skunk/lib |
|    |shell> MANPATH=scohelp:/usr/man:/usr/local1/man:/usr/local/man:/usr/skunk/man:        |
|    |First, create a Perl that includes a statically-linked DBI by running these commands  |
|    |in the directory where your DBI distribution is located:                              |
|    |                                                                                      |
|    |shell> perl Makefile.PL LINKTYPE=static                                               |
|    |shell> make                                                                           |
|    |shell> make install                                                                   |
|    |shell> make perl                                                                      |
|    |Then you must install the new Perl. The output of make perl will indicate the exact   |
|    |make command you will need to execute to perform the installation. On SCO, this is    |
|    |make -f Makefile.aperl inst_perl MAP_TARGET=perl.                                     |
|    |Next, use the just-created Perl to create another Perl that also includes a           |
|    |statically-linked DBD::mysql by running these commands in the directory where your    |
|    |Msql-Mysql-modules distribution is located:                                           |
|    |                                                                                      |
|    |shell> perl Makefile.PL LINKTYPE=static                                               |
|    |shell> make                                                                           |
|    |shell> make install                                                                   |
|    |shell> make perl                                                                      |
|    |Finally, you should install this new Perl. Again, the output of make perl indicates   |
|    |the command to use.                                                                   |
|    |4.11 Quelques spécificités liées aux OS                                               |
|    |The following sections indicate some of the issues that have been observed to occur on|
|    |particular systems when installing MySQL from a source distribution.                  |
|    |4.11.1 Solaris                                                                        |
|    |On Solaris, you may run into trouble even before you get the MySQL distribution       |
|    |unpacked! Solaris tar can't handle long file names, so you may see an error like this |
|    |when you unpack MySQL:                                                                |
|    |                                                                                      |
|    |x mysql-3.22.12-beta/bench/Results/ATIS-mysql_odbc-NT_4.0-cmp-db2,                    |
|    |informix,ms-sql,mysql,oracle,solid,sybase, 0 bytes, 0 tape blocks                     |
|    |tar: directory checksum error                                                         |
|    |In this case, you must use GNU tar (gtar) to unpack the distribution. You can find a  |
|    |precompiled copy for Solaris at http://www.mysql.com/Downloads/.                      |
|    |Sun native threads work only on Solaris 2.5 and higher. For 2.4 and earlier versions, |
|    |MySQL will automatically use MIT-pthreads. 4.9 Remarques sur MIT-pthreads.            |
|    |If you get the following error from configure:                                        |
|    |                                                                                      |
|    |checking for restartable system calls... configure: error can not run test            |
|    |programs while cross compiling                                                        |
|    |This means that you have something wrong with your compiler installation! In this case|
|    |you should upgrade your compiler to a newer version. You may also be able to solve    |
|    |this problem by inserting the following row into the config.cache file:               |
|    |                                                                                      |
|    |ac_cv_sys_restartable_syscalls=${ac_cv_sys_restartable_syscalls='no'}                 |
|    |If you are using Solaris on a SPARC, the recommended compiler is egcs 1.1.2 or newer. |
|    |You can find this at http://egcs.cygnus.com/. Note that egs 1.1.1 and gcc 2.8.1 don't |
|    |work reliably on SPARC!                                                               |
|    |The recommended configure line when using egcs 1.1.2 is:                              |
|    |                                                                                      |
|    |shell> CC=gcc CFLAGS="-O6"                                                            |
|    |CXX=gcc CXXFLAGS="-O6 -felide-constructors -fno-exceptions -fno-rtti"                 |
|    |./configure --prefix=/usr/local/mysql --with-low-memory                               |
|    |If you have the Sun Workshop 4.2 compiler, you can run configure like this:           |
|    |CC=cc CFLAGS="-xstrconst -Xa -xO4 -native -mt" CXX=CC CXXFLAGS="-xO4 -native -noex    |
|    |-mt" ./configure --prefix=/usr/local/mysql                                            |
|    |                                                                                      |
|    |shell> CC=cc CFLAGS="-Xa -fast -xO4 -native -xstrconst -mt" \                         |
|    |CXX=CC CXXFLAGS="-noex -XO4 -mt" \                                                    |
|    |./configure                                                                           |
|    |You may also have to edit the configure script to change this line:                   |
|    |                                                                                      |
|    |#if !defined(__STDC__) || __STDC__ != 1                                               |
|    |to this:                                                                              |
|    |                                                                                      |
|    |#if !defined(__STDC__)                                                                |
|    |If you turn on __STDC__ with the -Xc option, the Sun compiler can't compile with the  |
|    |Solaris `pthread.h' header file. This is a Sun bug (broken compiler or broken include |
|    |file).                                                                                |
|    |If mysqld issues the error message shown below when you run it, you have tried to     |
|    |compile MySQL with the Sun compiler without enabling the multi-thread option (-mt):   |
|    |                                                                                      |
|    |libc internal error: _rmutex_unlock: rmutex not held                                  |
|    |Add -mt to CFLAGS and CXXFLAGS and try again.                                         |
|    |If you get the following error when compiling MySQL with gcc, it means that your gcc  |
|    |is not configured for your version of Solaris!                                        |
|    |                                                                                      |
|    |shell> gcc -O3 -g -O2 -DDBUG_OFF  -o thr_alarm ...                                    |
|    |./thr_alarm.c: In function `signal_hand':                                             |
|    |./thr_alarm.c:556: too many arguments to function `sigwait'                           |
|    |The proper thing to do in this case is to get the newest version of egcs and compile  |
|    |it with your current gcc compiler! At least for Solaris 2.5, almost all binary        |
|    |versions of gcc have old, unusable include files that will break all programs that use|
|    |threads (and possibly other programs)!                                                |
|    |Solaris doesn't provide static versions of all system libraries (libpthreads and      |
|    |libdl), so you can't compile MySQL with --static. If you try to do so, you will get   |
|    |the error:                                                                            |
|    |                                                                                      |
|    |ld: fatal: library -ldl: not found                                                    |
|    |If too many processes try to connect very rapidly to mysqld, you will see this error  |
|    |in the MySQL log:                                                                     |
|    |                                                                                      |
|    |Error in accept: Protocol error                                                       |
|    |You might try starting the server with the --set-variable back_log=50 option as a     |
|    |workaround for this.                                                                  |
|    |If you are linking your own MySQL client, you might get the following error when you  |
|    |try to execute it:                                                                    |
|    |                                                                                      |
|    |ld.so.1: ./my: fatal: libmysqlclient.so.#: open failed: No such file or directory     |
|    |The problem can be avoided by one of the following méthodes:                          |
|    |Link the client with the following flag (instead of -Lpath):                          |
|    |-Wl,r/full-path-to-libmysqlclient.so.                                                 |
|    |Copy libmysqclient.so to `/usr/lib'.                                                  |
|    |Add the pathname of the directory where libmysqlclient.so is located to the           |
|    |LD_RUN_PATH environment variable before running your client.                          |
|    |4.11.2 Solaris 2.7                                                                    |
|    |You can normally use a Solaris 2.6 binary on Solaris 2.7. Most of the Solaris 2.6     |
|    |issues also apply for Solaris 2.7.                                                    |
|    |Solaris 2.7 has some bugs in the include files. You may see the following error when  |
|    |you use gcc:                                                                          |
|    |                                                                                      |
|    |/usr/include/widec.h:42: warning: `getwc' redefined                                   |
|    |/usr/include/wchar.h:326: warning: this is the location of the previous               |
|    |definition                                                                            |
|    |If this occurs, you can do the following to fix the problem:                          |
|    |Copy /usr/include/widec.h to .../lib/gcc-lib/os/gcc-version/include and change line 41|
|    |from:                                                                                 |
|    |                                                                                      |
|    |#if     !defined(lint) && !defined(__lint)                                            |
|    |                                                                                      |
|    |to                                                                                    |
|    |                                                                                      |
|    |#if     !defined(lint) && !defined(__lint) && !defined(getwc)                         |
|    |Alternatively, you can edit `/usr/include/widec.h' directly. Either way, after you    |
|    |make the fix, you should remove `config.cache' and run configure again!               |
|    |If you get errors like this when you run make, it's because configure didn't detect   |
|    |the `curses.h' file (probably because of the error in /usr/include/widec.h:           |
|    |                                                                                      |
|    |In file included from mysql.cc:50:                                                    |
|    |/usr/include/term.h:1060: syntax error before `,'                                     |
|    |/usr/include/term.h:1081: syntax error before `;'                                     |
|    |The solution to this is to do one of the following steps:                             |
|    |Edit `/usr/include/widec.h' as indicted above and rerun configure                     |
|    |Remove the #define HAVE_TERM line from `config.h' file and run make again.            |
|    |Configure with CFLAGS=-DHAVE_CURSES CXXFLAGS=-DCURSES ./configure                     |
|    |4.11.3 Solaris x86                                                                    |
|    |If you are using gcc or egcs on Solaris x86 and you experience problems with core     |
|    |dumps under load, you should use the following configure command:                     |
|    |                                                                                      |
|    |shell> CC=gcc CFLAGS="-O6 -fomit-frame-pointer" \                                     |
|    |CXX=gcc \                                                                             |
|    |CXXFLAGS="-O6 -fomit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" \  |
|    |./configure --prefix=/usr/local/mysql                                                 |
|    |This will avoid problems with the libstdc++ library and with C++ exceptions.          |
|    |If this doesn't help, you should compile a debug version and run it with a trace file |
|    |or under gdb. G.1 Debugguer un serveur MySQL.                                         |
|    |4.11.4 SunOS 4                                                                        |
|    |On SunOS 4, MIT-pthreads is needed to compile MySQL, which in turn means you will need|
|    |GNU make.                                                                             |
|    |Some SunOS 4 systems have problems with dynamic libraries and libtool. You can use the|
|    |following configure line to avoid this problem:                                       |
|    |                                                                                      |
|    |shell> ./configure --disable-shared --with-mysqld-ldflags=-all-static                 |
|    |When compiling readline, you may get warnings about duplicate defines. These may be   |
|    |ignored.                                                                              |
|    |When compiling mysqld, there will be some implicit declaration of function warnings.  |
|    |These may be ignored.                                                                 |
|    |4.11.5 Linux (Toutes versions de Linux)                                               |
|    |MySQL uses LinuxThreads on Linux. If you are using an old Linux version that doesn't  |
|    |have glibc2, you must install LinuxThreads before trying to compile MySQL.            |
|    |http://www.mysql.com/Downloads/Linux                                                  |
|    |If you can't start mysqld or if mysql_install_db doesn't work, please continue        |
|    |reading! This only happens on Linux system with problems in the LinuxThreads or       |
|    |libc/glibc libraries. There are a lot of simple workarounds to get MySQL to work! The |
|    |simplest is to use the binary version of MySQL (not the RPM) for Linux x86. One nice  |
|    |aspect of this version is that it's probably 10% faster than any version you would    |
|    |compile yourself! 10.3 Comment la compilation et le link affecte la vitesse de MySQL. |
|    |One known problem with the binary distribution is that with older Linux systems that  |
|    |use libc (like RedHat 4.x or Slackware), you will get some non-fatal problems with    |
|    |hostname resolution 4.6.3.1 Linux notes.                                              |
|    |isamchk hangs with libc.so.5.3.12. Upgrading to the newest libc fixes this problem.   |
|    |When using LinuxThreads you will see a minimum of three processes running. These are  |
|    |in fact threads. There will be one thread for the LinuxThreads manager, one thread to |
|    |handle connections, and one thread to handle alarms and signals.                      |
|    |If you see a dead mysqld daemon process with ps, this usually means that you have     |
|    |found a bug in MySQL or you have got a corrupted table. 18.1 Que faire si MySQL plante|
|    |constamment?.                                                                         |
|    |If you are using LinuxThreads and mysqladmin shutdown doesn't work, you must upgrade  |
|    |to LinuxThreads 0.7.1 or newer.                                                       |
|    |If you are using RedHat, you might get errors like this:                              |
|    |                                                                                      |
|    |/usr/bin/perl is needed...                                                            |
|    |/usr/sh is needed...                                                                  |
|    |/usr/sh is needed...                                                                  |
|    |If so, you should upgrade your version of rpm to `rpm-2.4.11-1.i386.rpm' and          |
|    |`rpm-devel-2.4.11-1.i386.rpm' (or later).                                             |
|    |You can get the upgrades of libraries to RedHat 4.2 from                              |
|    |ftp://ftp.redhat.com/updates/4.2/i386. Or                                             |
|    |http://www.sunsite.unc.edu/pub/Linux/distributions/redhat/code/rpm/ for other         |
|    |distributions.                                                                        |
|    |If you are linking your own MySQL client and get the error:                           |
|    |                                                                                      |
|    |ld.so.1: ./my: fatal: libmysqlclient.so.4: open failed: No such file or directory     |
|    |when executing them, the problem can be avoided by one of the following méthodes:     |
|    |Link the client with the following flag (instead of -Lpath):                          |
|    |-Wl,r/path-libmysqlclient.so.                                                         |
|    |Copy libmysqclient.so to `/usr/lib'.                                                  |
|    |Add the pathname of the directory where libmysqlclient.so is located to the           |
|    |LD_RUN_PATH environment variable before running your client.                          |
|    |If you are using the Fujitsu compiler (fcc / FCC) you will have some problems         |
|    |compiling MySQL because the Linux header files are very gcc oriented.                 |
|    |The following configure line should work with fcc/FCC:                                |
|    |                                                                                      |
|    |CC=fcc CFLAGS="-O -K fast -K lib -K omitfp -Kpreex -D_GNU_SOURCE -DCONST=const        |
|    |-DNO_STRTOLL_PROTO" CXX=FCC CXXFLAGS="-O -K fast -K lib  -K omitfp -K preex           |
|    |--no_exceptions --no_rtti -D_GNU_SOURCE -DCONST=const -Dalloca=__builtin_alloca       |
|    |-DNO_STRTOLL_PROTO '-D_EXTERN_INLINE=static __inline'" ./configure                    |
|    |--prefix=/usr/local/mysql --enable-assembler --with-mysqld-ldflags=-all-static        |
|    |--disable-shared --with-low-memory                                                    |
|    |4.11.5.1 Linux-x86                                                                    |
|    |MySQL requires libc version 5.4.12 or newer. It's known to work with libc 5.4.46.     |
|    |glibc version 2.0.6 and later should also work. There have been some problems with the|
|    |glibc RPMs from RedHat so if you have problems, check whether or not there are any    |
|    |updates! The glibc 2.0.7-19 and 2.0.7-29 RPMs are known to work.                      |
|    |On some older Linux distributions, configure may produce an error like this:          |
|    |                                                                                      |
|    |Syntax error in sched.h. Change _P to __P in the /usr/include/sched.h file.           |
|    |See the Installation chapter in the Reference Manual.                                 |
|    |Just do what the error message says and add an extra underscore to the _P macro that  |
|    |has only one underscore, then try again.                                              |
|    |You may get some warnings when compiling; those shown below can be ignored:           |
|    |                                                                                      |
|    |mysqld.cc -o objs-thread/mysqld.o                                                     |
|    |mysqld.cc: In function `void init_signals()':                                         |
|    |mysqld.cc:315: warning: assignment of negative value `-1' to `long unsigned int'      |
|    |mysqld.cc: In function `void * signal_hand(void *)':                                  |
|    |mysqld.cc:346: warning: assignment of negative value `-1' to `long unsigned int'      |
|    |In Debian GNU/Linux, if you want MySQL to start automatically when the system boots,  |
|    |do the following:                                                                     |
|    |                                                                                      |
|    |shell> cp support-files/mysql.server /etc/init.d/mysql.server                         |
|    |shell> /usr/sbin/update-rc.d mysql.server defaults 99                                 |
|    |mysql.server can be found in the `share/mysql' directory under the MySQL installation |
|    |directory, or in the `support-files' directory of the MySQL source tree.              |
|    |If mysqld always core dumps when it starts up, the problem may be that you have an old|
|    |`/lib/libc.a'. Try renaming it, then remove `sql/mysqld' and do a new make install and|
|    |try again. This problem has been reported on some Slackware installations. RedHat 5.0 |
|    |has also a similar problem with some new glibc versions. 4.11.5.2 RedHat 5.0.         |
|    |If you get the following error when linking mysqld, it means that your `libg++.a' is  |
|    |not installed correctly:                                                              |
|    |                                                                                      |
|    |/usr/lib/libc.a(putc.o): In function `_IO_putc':                                      |
|    |putc.o(.text+0x0): multiple definition of `_IO_putc'                                  |
|    |You can avoid using `libg++.a' by running configure like this:                        |
|    |                                                                                      |
|    |shell> CXX=gcc ./configure                                                            |
|    |4.11.5.2 RedHat 5.0                                                                   |
|    |If you have any problems with MySQL on RedHat, you should start by upgrading glibc to |
|    |the newest possible version!                                                          |
|    |If you install all the official RedHat patches (including glibc-2.0.7-19 and          |
|    |glibc-devel-2.0.7-19), both the binary and source distributions of MySQL should work  |
|    |without any trouble!                                                                  |
|    |The updates are needed since there is a bug in glibc 2.0.5 in how pthread_key_create  |
|    |variables are freed. With glibc 2.0.5, you must use a statically-linked MySQL binary  |
|    |distribution. If you want to compile from source, you must install the corrected      |
|    |version of LinuxThreads from http://www.mysql.com/Downloads/Linux or upgrade your     |
|    |glibc.                                                                                |
|    |If you have an incorrect version of glibc or LinuxThreads, the symptom is that mysqld |
|    |crashes after each connection. For example, mysqladmin version will crash mysqld when |
|    |it finishes!                                                                          |
|    |Another symptom of incorrect libraries is that mysqld crashes at once when it starts. |
|    |On some Linux systems, this can be fixed by configuring like this:                    |
|    |                                                                                      |
|    |shell> ./configure --with-mysqld-ldflags=-all-static                                  |
|    |On Redhat 5.0, the easy way out is to install the glibc 2.0.7-19 RPM and run configure|
|    |without the --with-mysqld-ldflags=-all-static option.                                 |
|    |For the source distribution of glibc 2.0.7, a patch that is easy to apply and is      |
|    |tested with MySQL may be found at:                                                    |
|    |                                                                                      |
|    |http://www.mysql.com/Download/Linux/glibc-2.0.7-total-patch.tar.gz                    |
|    |If you experience crashes like these when you build MySQL, you can always download the|
|    |newest binary version of MySQL. This is statically-linked to avoid library conflicts  |
|    |and should work on all Linux systems!                                                 |
|    |MySQL comes with an internal debugger that can generate trace files with a lot of     |
|    |information that can be used to find and solve a wide range of different problems. G.1|
|    |Debugguer un serveur MySQL.                                                           |
|    |4.11.5.3 RedHat 5.1                                                                   |
|    |The glibc of RedHat 5.1 (glibc 2.0.7-13) has a memory leak, so to get a stable MySQL  |
|    |version, you must upgrade glibc to 2.0.7-19, downgrade glibc or use a binary version  |
|    |of mysqld. If you don't do this, you will encounter memory problems (out of memory,   |
|    |etc., etc.). The most common error in this case is:                                   |
|    |                                                                                      |
|    |Can't create a new thread (errno 11). If you are not out of available                 |
|    |memory, you can consult the manual for any possible OS dependent bug                  |
|    |After you have upgraded to glibc 2.0.7-19, you can configure MySQL with dynamic       |
|    |linking (the default), but you cannot run configure with the                          |
|    |--with-mysqld-ldflags=-all-static option until you have installed glibc 2.0.7-19 from |
|    |source!                                                                               |
|    |You can check which version of glibc you have with rpm -q glibc.                      |
|    |4.11.5.4 Linux-SPARC                                                                  |
|    |In some implementations, readdir_r() is broken. The symptom is that SHOW DATABASES    |
|    |always returns an empty set. This can be fixed by removing HAVE_READDIR_R from        |
|    |`config.h' after configuring and before compiling.                                    |
|    |Some problems will require patching your Linux installation. The patch can be found at|
|    |http://www.mysql.com/patches/Linux-sparc-2.0.30.diff. This patch is against the Linux |
|    |distribution `sparclinux-2.0.30.tar.gz' that is available at vger.rutgers.edu (a      |
|    |version of Linux that was never merged with the official 2.0.30). You must also       |
|    |install LinuxThreads 0.6 or newer.                                                    |
|    |Thanks to [e-mail] for this information.                                |
|    |4.11.5.5 Linux-Alpha                                                                  |
|    |The big problem on Linux-Alpha is that there are still some problems with threads in  |
|    |glibc on this platform. You should start by getting the newest glibc version you can  |
|    |find.                                                                                 |
|    |Note that before you run any programs that use threads (like mysqld, thr_alarm or     |
|    |thr_lock), you should raise the shared memory limit (with ulimit). The MySQL          |
|    |benchmarks are known to fail if you forget to do this!                                |
|    |Configure MySQL with the following command:                                           |
|    |                                                                                      |
|    |shell> CC=gcc CCFLAGS="-Dalpha_linux_port" \                                          |
|    |CXX=gcc CXXFLAGS="-O3 -Dalpha_linux_port -felide-constructors -fno-exceptions         |
|    |-fno-rtti" \                                                                          |
|    |./configure --prefix=/usr/local/mysql                                                 |
|    |Try to compile mysys/thr_lock and mysys/thr_alarm. Test that these programs work!     |
|    |(Invoke each one with no arguments. Each should end with test_succeeded if everything |
|    |was okay.)                                                                            |
|    |After installing MySQL, uncomment the ulimit command in safe_mysqld and add options to|
|    |increase shared memory.                                                               |
|    |Note that Linux-Alpha is still an alpha-quality platform for MySQL. With the newest   |
|    |glibc, you have a very good chance of it working.                                     |
|    |If you have problems with signals (MySQL dies unexpectedly under high load) you may   |
|    |have found an OS bug with threads and signals. In this case you can tell MySQL not to |
|    |use signals by configuring with:                                                      |
|    |                                                                                      |
|    |shell> CFLAGS=-DDONT_USE_THR_ALARM \                                                  |
|    |CXXFLAGS=-DDONT_USE_THR_ALARM \                                                       |
|    |./configure ...                                                                       |
|    |This doesn't affect the performance of MySQL, but has the side effect that you can't  |
|    |kill clients that are ``sleeping'' on a connection with mysqladmin kill or mysqladmin |
|    |shutdown. Instead, the client will die when it issues its next command.               |
|    |4.11.5.6 MkLinux                                                                      |
|    |MySQL should work on MkLinux with the newest glibc package (tested with glibc 2.0.7). |
|    |4.11.5.7 Qube2 Linux                                                                  |
|    |To get MySQL to work on Qube2, (Linux Mips), you need the newest glibc libraries      |
|    |(glibc-2.0.7-29C2 is known to work). You must also use the egcs C++ compiler          |
|    |(egcs-1.0.2-9 or newer).                                                              |
|    |4.11.6 Alpha-DEC-Unix                                                                 |
|    |When compiling threaded programs under Digital UNIX, the documentation recommends     |
|    |using the -pthread option for cc and cxx and the libraries -lmach -lexc (in addition  |
|    |to -lpthread). You should run configure something like this:                          |
|    |                                                                                      |
|    |shell> CC="cc -pthread" CXX="cxx -pthread -O" \                                       |
|    |./configure --with-named-thread-libs="-lpthread -lmach -lexc -lc"                     |
|    |When compiling mysqld, you may see a couple of warnings like this:                    |
|    |                                                                                      |
|    |mysqld.cc: In function void handle_connections()':                                    |
|    |mysqld.cc:626: passing long unsigned int *' as argument 3 of                          |
|    |accept(int,sockadddr *, int *)'                                                       |
|    |You can safely ignore these warnings. They occur because configure can detect only    |
|    |errors, not warnings.                                                                 |
|    |If you start the server directly from the command line, you may have problems with it |
|    |dying when you log out. (When you log out, your outstanding processes receive a SIGHUP|
|    |signal.) If so, try starting the server like this:                                    |
|    |                                                                                      |
|    |shell> nohup mysqld [options] &                                                       |
|    |nohup causes the command following it to ignore any SIGHUP signal sent from the       |
|    |terminal. Alternatively, start the server by running safe_mysqld, which invokes mysqld|
|    |using nohup for you.                                                                  |
|    |4.11.7 Alpha-DEC-OSF1                                                                 |
|    |If you have problems compiling and have DEC CC and gcc installed, try running         |
|    |configure like this:                                                                  |
|    |                                                                                      |
|    |shell> CC=cc CFLAGS=-O CXX=gcc CXXFLAGS=-O3 \                                         |
|    |./configure --prefix=/usr/local/mysql                                                 |
|    |If you get problems with the `c_asm.h' file, you can create and use a 'dummy'         |
|    |`c_asm.h' file with:                                                                  |
|    |                                                                                      |
|    |shell> touch include/c_asm.h                                                          |
|    |shell> CC=gcc CFLAGS=-I./include \                                                    |
|    |CXX=gcc CXXFLAGS=-O3 \                                                                |
|    |./configure --prefix=/usr/local/mysql                                                 |
|    |On OSF1 V4.0D and compiler "DEC C V5.6-071 on Digital UNIX V4.0 (Rev. 878)" the       |
|    |compiler had some strange behavior (undefined asm symbols). /bin/ld also appears to be|
|    |broken (problems with _exit undefined errors occuring while linking mysqld). On this  |
|    |system, we have managed to compile MySQL with the following configure line, after     |
|    |replacing /bin/ld with the version from OSF 4.0C:                                     |
|    |                                                                                      |
|    |shell> CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql              |
|    |In some versions of OSF1, the alloca() function is broken. Fix this by removing the   |
|    |line in `config.h' that defines 'HAVE_ALLOCA'.                                        |
|    |The alloca() function also may have an incorrect prototype in /usr/include/alloca.h.  |
|    |This warning resulting from this can be ignored.                                      |
|    |configure will use the following thread libraries automatically:                      |
|    |--with-named-thread-libs="-lpthread -lmach -lexc -lc".                                |
|    |When using gcc, you can also try running configure like this:                         |
|    |                                                                                      |
|    |shell> CFLAGS=-D_PTHREAD_USE_D4 CXX=gcc CXXFLAGS=-O3 ./configure ....                 |
|    |If you have problems with signals (MySQL dies unexpectedly under high load) you may   |
|    |have found an OS bug with threads and signals. In this case you can tell MySQL not to |
|    |use signals by configuring with:                                                      |
|    |                                                                                      |
|    |shell> CFLAGS=-DDONT_USE_THR_ALARM \                                                  |
|    |CXXFLAGS=-DDONT_USE_THR_ALARM \                                                       |
|    |./configure ...                                                                       |
|    |This doesn't affect the performance of MySQL, but has the side effect that you can't  |
|    |kill clients that are ``sleeping'' on a connection with mysqladmin kill or mysqladmin |
|    |shutdown. Instead, the client will die when it issues its next command.               |
|    |4.11.8 SGI-Irix                                                                       |
|    |You may have to undefine some things in `config.h' after running configure and before |
|    |compiling.                                                                            |
|    |In some Irix implementations, the alloca() function is broken. If the mysqld server   |
|    |dies on some SELECT statements, remove the lines from `config.h' that define          |
|    |HAVE_ALLOC and HAVE_ALLOCA_H. If mysqladmin create doesn't work, remove the line from |
|    |`config.h' that defines HAVE_READDIR_R. You may have to remove the HAVE_TERM_H line as|
|    |well.                                                                                 |
|    |SGI recommends that you install all of the patches on this page as a set:             |
|    |http://support.sgi.com/surfzone/patches/patchset/6.2_indigo.rps.html                  |
|    |At the very minimum, you should install the latest kernel rollup, the latest rld      |
|    |rollup, and the latest libc rollup.                                                   |
|    |You definately need all the POSIX patches on this page, for pthreads support:         |
|    |http://support.sgi.com/surfzone/patches/patchset/6.2_posix.rps.html                   |
|    |If you get the something like the following error when compiling `mysql.cc':          |
|    |                                                                                      |
|    |"/usr/include/curses.h", line 82: error(1084): invalid combination of type            |
|    |Then type the following in the top-level directory of your MySQL source tree:         |
|    |                                                                                      |
|    |shell> extra/replace bool curses_bool < /usr/include/curses.h > include/curses.h      |
|    |shell> make                                                                           |
|    |There have also been reports of scheduling problems. If only one thread is running,   |
|    |things go slow. Avoid this by starting another client. This may lead to a 2-to-10-fold|
|    |increase in execution speed thereafter for the other thread. This is a                |
|    |poorly-understood problem with Irix threads; you may have to improvise to find        |
|    |solutions until this can be fixed.                                                    |
|    |If you are compiling with gcc, you can use the following configure command:           |
|    |                                                                                      |
|    |shell> CC=gcc CXX=gcc CXXFLAGS=-O3 \                                                  |
|    |./configure --prefix=/usr/local/mysql --with-thread-safe-client \                     |
|    |--with-named-thread-libs=-lpthread                                                    |
|    |4.11.9 FreeBSD                                                                        |
|    |If you notice that configure will use MIT-pthreads, you should read the MIT-pthreads  |
|    |notes. 4.9 Remarques sur MIT-pthreads.                                                |
|    |If you get an error from make install that it can't find `/usr/include/pthreads',     |
|    |configure didn't detect that you need MIT-pthreads. This is fixed by executing these  |
|    |commands:                                                                             |
|    |                                                                                      |
|    |shell> rm config.cache                                                                |
|    |shell> ./configure --with-mit-threads                                                 |
|    |The behavior of FreeBSD make is slightly different from that of GNU make. If you have |
|    |make-related problems, you should install GNU make.                                   |
|    |If mysql or mysqladmin takes a long time to respond, a user said the following:       |
|    |Are you running the ppp user process? On one FreeBSD box (2.2.5) MySQL clients takes a|
|    |couple of seconds to connect to mysqld if the ppp process is running.                 |
|    |FreeBSD is also known to have a very low default file handle limit. 18.10 File not    |
|    |found.                                                                                |
|    |If you have a problem with SELECT NOW() returning values in GMT and not your local    |
|    |time, you have to set the TZ environment variable to your current timezone. This      |
|    |should be done for the environment in which the server runs, for example, in          |
|    |safe_mysqld or mysql.server.                                                          |
|    |Make sure that the localhost entry in the `/etc/hosts' file is correct (otherwise you |
|    |will have problems connecting to the database). The `/etc/hosts' file should start    |
|    |with a line:                                                                          |
|    |                                                                                      |
|    |127.0.0.1       localhost localhost.your.domain                                       |
|    |If you are using FreeBSD 2.2.6, don't forget to apply the ttcp and mmap-22 patches to |
|    |the OS (for security reasons). Please see http://www.freebsd.org for these CERT       |
|    |patches.                                                                              |
|    |If you are using FreeBSD 2.2.7 and you have problems killing the mysqld daemon, you   |
|    |should get new sources using cvsup and recompile libc_r.                              |
|    |4.11.9.1 FreeBSD-3.0                                                                  |
|    |You have to run configure with the --with-named-thread-libs=-lc_r option.             |
|    |The pthreads library for FreeBSD doesn't contain the sigwait() function and there are |
|    |some bugs in it. To fix this, get the `FreeBSD-3.0-libc_r-1.0.diff' file from the     |
|    |FreeBSD area of the MySQL FTP site and apply it in the `/usr/src/lib/libc_r/uthread'  |
|    |directory. Then follow the instructions that can be found with man pthread about how  |
|    |to recompile the libc_r library.                                                      |
|    |You can test if you have a ``modern'' libpthread.a with this command:                 |
|    |                                                                                      |
|    |shell> nm /usr/lib/libc_r.a | grep sigwait                                            |
|    |If the above doesn't find sigwait, you must use the patch above and recompile libc_r. |
|    |4.11.10 NetBSD                                                                        |
|    |To compile on NetBSD you need GNU make. Otherwise the compile will crash when make    |
|    |tries to run lint on C++ files.                                                       |
|    |4.11.11 BSD/OS                                                                        |
|    |4.11.11.1 BSD/OS 2.x                                                                  |
|    |If you get the following error when compiling MySQL, your ulimit value for virtual    |
|    |memory is too low:                                                                    |
|    |                                                                                      |
|    |item_func.h: In méthode `Item_func_ge::Item_func_ge(const Item_func_ge &)':           |
|    |item_func.h:28: virtual memory exhausted                                              |
|    |make[2]: *** [item_func.o] Error 1                                                    |
|    |Try using ulimit -v 80000 and run make again. If this doesn't work and you are using  |
|    |bash, try switching to csh or sh; some BSDI users have reported problems with bash and|
|    |ulimit.                                                                               |
|    |If you are using gcc, you may also use have to use the --with-low-memory flag for     |
|    |configure to be able to compile `sql_yacc.cc'.                                        |
|    |If you have a problem with SELECT NOW() returning values in GMT and not your local    |
|    |time, you have to set the TZ environment variable to your current timezone. This      |
|    |should be done for the environment in which the server runs, for example in           |
|    |safe_mysqld or mysql.server.                                                          |
|    |4.11.11.2 BSD/OS 3.x                                                                  |
|    |Upgrade to BSD/OS 3.1. If that is not possible, install BSDIpatch M300-038.           |
|    |Use the following command when configuring MySQL:                                     |
|    |                                                                                      |
|    |shell> env CXX=shlicc++ CC=shlicc2 \                                                  |
|    |./configure \                                                                         |
|    |--prefix=/usr/local/mysql \                                                           |
|    |--localstatedir=/var/mysql \                                                          |
|    |--without-perl \                                                                      |
|    |--with-unix-socket-path=/var/mysql/mysql.sock                                         |
|    |The following is also known to work:                                                  |
|    |                                                                                      |
|    |shell> env CC=gcc CXX=gcc CXXFLAGS=-O3 \                                              |
|    |./configure \                                                                         |
|    |--prefix=/usr/local/mysql \                                                           |
|    |--with-unix-socket-path=/var/mysql/mysql.sock                                         |
|    |You can change the directory locations if you wish, or just use the defaults by not   |
|    |specifying any locations.                                                             |
|    |If you have problems with performance under heavy load, try using the                 |
|    |--skip-thread-priority option to safe_mysqld! This will run all threads with the same |
|    |priority; on BSDI 3.1, this gives better performance (at least until BSDI fixes their |
|    |thread scheduler).                                                                    |
|    |If you get the error virtual memory exhausted while compiling, you should try using   |
|    |ulimit -v 80000 and run make again. If this doesn't work and you are using bash, try  |
|    |switching to csh or sh; some BSDI users have reported problems with bash and ulimit.  |
|    |4.11.11.3 BSD/OS 4.x                                                                  |
|    |BSDI 4.x has some thread related bugs. If you want to use MySQL on this, you should   |
|    |install all thread related patches. At least M400-023 should be installed.            |
|    |4.11.12 SCO                                                                           |
|    |The current port is tested only on a ``sco3.2v5.0.4'' and ``sco3.2v5.0.5'' system.    |
|    |There has also been a lot of progress on a port to ``sco 3.2v4.2''.                   |
|    |For OpenServer 5.0.X you need to use GDS in Skunkware 95 (95q4c). This is necessary   |
|    |because GNU gcc 2.7.2 in Skunkware 97 does not have GNU as. You can also use egcs     |
|    |1.1.2 or newer http://www.egcs.com/. If you are using egcs 1.1.2 you have to execute  |
|    |the following command:                                                                |
|    |                                                                                      |
|    |shell> cp -p /usr/include/pthread/stdtypes.h                                          |
|    |/usr/local/lib/gcc-lib/i386-pc-sco3.2v5.0.5/egcs-2.91.66/include/pthread/             |
|    |You need the port of GCC 2.5.? for this product and the Development system. They are  |
|    |required on this version of SCO UNIX. You cannot just use the GCC Dev system.         |
|    |You should get the FSU Pthreads package and install it first. This can be found at    |
|    |http://www.cs.wustl.edu/~schmidt/ACE_wrappers/FSU-threads.tar.gz. You can also get a  |
|    |precompiled package from                                                              |
|    |ftp://www.mysql.com/pub/mysql/Downloads/SCO/FSU-threads-3.5c.tar.gz.                  |
|    |FSU Pthreads can be compiled with SCO UNIX 4.2 with tcpip. Or OpenServer 3.0 or Open  |
|    |Desktop 3.0 (OS 3.0 ODT 3.0), with the SCO Development System installed using a good  |
|    |port of GCC 2.5.X ODT or OS 3.0 you will need a good port of GCC 2.5.? There are a lot|
|    |of problems without a good port. The port for this product requires the SCO UNIX      |
|    |Development system. Without it, you are missing the libraries and the linker that is  |
|    |needed.                                                                               |
|    |To build FSU Pthreads on your system, do the following:                               |
|    |Run ./configure in the `threads/src' directory and select the SCO OpenServer option.  |
|    |This command copies `Makefile.SCO5' to `Makefile'.                                    |
|    |Run make.                                                                             |
|    |To install in the default `/usr/include' directory, login as root, then cd to the     |
|    |`thread/src' directory, and run make install.                                         |
|    |Remember to use GNU make when making MySQL.                                           |
|    |On OSR 5.0.5, you should use the following configure line:                            |
|    |                                                                                      |
|    |shell> CC="gcc -DSCO" CXX="gcc -DSCO" ./configure                                     |
|    |The -DSCO is needed to help configure detect some thread functions properly. If you   |
|    |forget -DSCO, you will get the following error message while compiling:               |
|    |                                                                                      |
|    |my_pthread.c: In function `my_pthread_mutex_init':                                    |
|    |my_pthread.c:374: `pthread_mutexattr_default' undeclared (first use this function)    |
|    |If you don't start safe_mysqld as root, you probably will get only the default 110    |
|    |open files per process. mysqld will write a note about this in the log file.          |
|    |With SCO 3.2V5.0.5, you should use a FSU Pthreads version 3.5c or newer. The following|
|    |configure command should work:                                                        |
|    |                                                                                      |
|    |shell> CC="gcc -belf" ./configure --prefix=/usr/local/mysql --disable-shared          |
|    |With SCO 3.2V4.2, you should use a FSU Pthreads version 3.5c or newer. The following  |
|    |configure command should work:                                                        |
|    |                                                                                      |
|    |shell> CFLAGS="-D_XOPEN_XPG4" CXX=gcc CXXFLAGS="-D_XOPEN_XPG4" \                      |
|    |./configure \                                                                         |
|    |--with-debug --prefix=/usr/local/mysql \                                              |
|    |--with-named-thread-libs="-lgthreads -lsocket -lgen -lgthreads" \                     |
|    |--with-named-curses-libs="-lcurses"                                                   |
|    |You may get some problems with some include files. In this case, you can find new     |
|    |SCO-specific include files at                                                         |
|    |ftp://www.mysql.com/pub/mysql/Downloads/SCO/SCO-3.2v4.2-includes.tar.gz. You should   |
|    |unpack this file in the `include' directory of your MySQL source tree.                |
|    |SCO development notes:                                                                |
|    |MySQL should automatically detect FSU Pthreads and link mysqld with -lgthreads        |
|    |-lsocket -lgthreads.                                                                  |
|    |The SCO development libraries are reentrant in FSU Pthreads. SCO claims that its      |
|    |libraries' functions are reentrant, so they must be reentrant with FSU Pthreads. FSU  |
|    |Pthreads on OpenServer tries to use the SCO scheme to make reentrant library.         |
|    |FSU Pthreads (at least the version at www.mysql.com) comes linked with GNU malloc. If |
|    |you encounter problems with memory usage, make sure that `gmalloc.o' is included in   |
|    |`libgthreads.a' and `libgthreads.so'.                                                 |
|    |In FSU Pthreads, the following system calls are pthreads-aware: read(), write(),      |
|    |getmsg(), connect(), accept(), select() and wait().                                   |
|    |If you want to install DBI on SCO, you have to edit the `Makefiles' in DBI-xxx and    |
|    |each subdirectory:                                                                    |
|    |                                                                                      |
|    |OLD:                                  NEW:                                            |
|    |CC = cc                               CC = gcc -belf                                  |
|    |CCCDLFLAGS = -KPIC -W1,-Bexport       CCCDLFLAGS = -fpic                              |
|    |CCDLFLAGS = -wl,-Bexport              CCDLFLAGS =                                     |
|    |                                                                                      |
|    |LD = ld                               LD = gcc -belf -G -fpic                         |
|    |LDDLFLAGS = -G -L/usr/local/lib       LDDLFLAGS = -L/usr/local/lib                    |
|    |LDFLAGS = -belf -L/usr/local/lib      LDFLAGS = -L/usr/local/lib                      |
|    |                                                                                      |
|    |LD = ld                               LD = gcc -belf -G -fpic                         |
|    |OPTIMISE = -Od                 OPTIMISE = -O1                                         |
|    |                                                                                      |
|    |OLD:                                                                                  |
|    |CCCFLAGS = -belf -dy -w0 -U M_XENIX -DPERL_SCO5 -I/usr/local/include                  |
|    |                                                                                      |
|    |NEW:                                                                                  |
|    |CCFLAGS = -U M_XENIX -DPERL_SCO5 -I/usr/local/include                                 |
|    |This is because the Perl dynaloader will not load the DBI modules if they were        |
|    |compiled with icc or cc.                                                              |
|    |Perl works best when compiled with cc.                                                |
|    |4.11.13 SCO Unixware 7.0 notes                                                        |
|    |You must use a version of MySQL at least as recent as 3.22.13, since that version     |
|    |fixes some portability problems under Unixware.                                       |
|    |We have been able to compile MySQL with the following configure command on UnixWare   |
|    |7.0.1:                                                                                |
|    |                                                                                      |
|    |shell> CC=cc CXX=CC ./configure --prefix=/usr/local/mysql                             |
|    |4.11.14 IBM-AIX                                                                       |
|    |Automatic detection of xlC is missing from Autoconf, so a configure command something |
|    |like this is needed when using the IBM compiler:                                      |
|    |                                                                                      |
|    |shell> CC="xlc_r -ma -O3 -qstrict -DHAVE_INT_8_16_32" \                               |
|    |CXX="xlC_r -ma -O3 -qstrict -DHAVE_INT_8_16_32" \                                     |
|    |./configure                                                                           |
|    |If you are using egcs to compile MySQL, you MUST use the -fno-exceptions flag, as the |
|    |exception handling in egcs is not thread-safe! (This is tested with egcs 1.1.) We     |
|    |recommend the following configure line with egcs and gcc on AIX:                      |
|    |                                                                                      |
|    |shell> CXX=gcc \                                                                      |
|    |CXXFLAGS="-felide-constructors -fno-exceptions -fno-rtti" \                           |
|    |./configure --prefix=/home/monty --with-debug --with-low-memory                       |
|    |If you have problems with signals (MySQL dies unexpectedly under high load) you may   |
|    |have found an OS bug with threads and signals. In this case you can tell MySQL not to |
|    |use signals by configuring with:                                                      |
|    |                                                                                      |
|    |shell> CFLAGS=-DDONT_USE_THR_ALARM CXX=gcc \                                          |
|    |CXXFLAGS="-felide-constructors -fno-exceptions -fno-rtti -DDONT_USE_THR_ALARM" \      |
|    |./configure --prefix=/home/monty --with-debug --with-low-memory                       |
|    |This doesn't affect the performance of MySQL, but has the side effect that you can't  |
|    |kill clients that are ``sleeping'' on a connection with mysqladmin kill or mysqladmin |
|    |shutdown. Instead, the client will die when it issues its next command.               |
|    |4.11.15 HP-UX                                                                         |
|    |There are a couple of ``small'' problems when compiling MySQL on HP-UX. We recommend  |
|    |that you use gcc instead of the HP-UX native compiler, because gcc produces better    |
|    |code!                                                                                 |
|    |We recommend one to use gcc 2.95 on HP-UX. Don't use high optimization flags (like    |
|    |-O6) as this may not be safe on HP-UX.                                                |
|    |Note that MIT-pthreads can't be compiled with the HP-UX compiler, because it can't    |
|    |compile .S (assembler) files.                                                         |
|    |The following configure line should work:                                             |
|    |                                                                                      |
|    |CFLAGS="-DHPUX -I/opt/dce/include" CXXFLAGS="-DHPUX -I/opt/dce/include                |
|    |-felide-constructors -fno-exceptions -fno-rtti" CXX=gcc ./configure --with-pthread    |
|    |--with-named-thread-libs='-ldce' --prefix=/usr/local/mysql --disable-shared           |
|    |If you are compiling gcc 2.95 yourself, you should NOT link it with the DCE libraries |
|    |(libdce.a or libcma.a) if you want to compile MySQL with MIT-pthreads. If you mix the |
|    |DCE and MIT-pthreads packages you will get a mysqld to which you cannot connect.      |
|    |Remove the DCE libraries while you compile gcc 2.95!                                  |
|    |4.12 Remarques pour Win32                                                             |
|    |This section describes installation and use of MySQL on Win32. This is also described |
|    |in the `README' file that comes with the MySQL Win32 distribution.                    |
|    |4.12.1 Installer strong{MySQL} sous Win32                                             |
|    |If you don't have a registered version of MySQL, you should first download the        |
|    |shareware version from:                                                               |
|    |MySQL 3.21.29                                                                         |
|    |If you plan to connect to MySQL from some other program, you will probably also need  |
|    |the MyODBC driver. You can find this at the MySQL download page.                      |
|    |To install either distribution, unzip it in some empty directory and run the Setup.exe|
|    |program.                                                                              |
|    |Installation takes place in `C:\mysql'.                                               |
|    |4.12.2 Démarrer MySQL sous Win95 / Win98                                              |
|    |MySQL uses TCP/IP to connect a client to a server. (This will allow any machine on    |
|    |your network to connect to your MySQL server). Because of this, you must install      |
|    |TCP/IP on your machine before starting MySQL. You can find TCP/IP on your Windows     |
|    |CD-ROM.                                                                               |
|    |Note that if you are using an old Win95 release (for example OSR2), it's likely that  |
|    |you have an old Winsock package! MySQL requires Winsock 2! You can get the newest     |
|    |Winsock from Microsoft. Win98 has as default the new Winsock 2 library, so the above  |
|    |doesn't apply for Win98.                                                              |
|    |There are 2 different MySQL servers you can use:                                      |
|    |mysqld                                                                                |
|    |Compiled with full debugging and automatic memory allocation checking                 |
|    |                                                                                      |
|    |mysqld-opt                                                                            |
|    |Optimized for a Pentium processor.                                                    |
|    |                                                                                      |
|    |Both of the above should work on any Intel processor >= i386.                         |
|    |To start the mysqld server, you should start a MS-DOS window and type:                |
|    |                                                                                      |
|    |C:\mysql\bin\mysqld                                                                   |
|    |This will start mysqld in the background without a window.                            |
|    |You can kill the MySQL server by executing:                                           |
|    |                                                                                      |
|    |C:\mysql\bin\mysqladmin -u root shutdown                                              |
|    |Note that Win95/Win98 don't support creation of named pipes. On Win95/Win98, you can  |
|    |only use named pipes to connect to a remote MySQL running on an NT server.            |
|    |4.12.3 Démarrer MySQL sous NT                                                         |
|    |The Win95/Win98 section also applies to MySQL on NT, with the following differences:  |
|    |To get MySQL to work with TCP/IP, you must install service pack 3 (or newer)!         |
|    |For NT, the server name is mysqld-nt. Normally you should install MySQL as a service  |
|    |on NT:                                                                                |
|    |                                                                                      |
|    |C:\mysql\bin\mysqld-nt --install                                                      |
|    |(You could use the mysqld or mysqld-opt servers on NT, but those cannot be started as |
|    |a service or use named pipes.)                                                        |
|    |You can start and stop the MySQL service with:                                        |
|    |                                                                                      |
|    |NET START mysql                                                                       |
|    |NET STOP mysql                                                                        |
|    |Note that in this case you can't use any other options for mysqld-nt!                 |
|    |You can also run mysqld-nt as a standalone program on NT if you need to start         |
|    |mysqld-nt with any options! If you start mysqld-nt without options on NT, mysqld-nt   |
|    |tries to starts itself as a service with the default service options. If you have     |
|    |stopped mysqld-nt, you have to start it with NET START mysql.                         |
|    |The service is installed with the name MySql. Once installed, it must be started using|
|    |Services Control Manager (SCM) Utility (found in Control Panel) or by using the NET   |
|    |START MySQL command. If any options are desired, they must be specified as "Startup   |
|    |parameters" in the SCM utility before you start the MySQL service. Once running,      |
|    |mysqld-nt can be stopped using mysqladmin or from the SCM utility or by using the     |
|    |command NET STOP MySQL. If you use SCM to stop mysqld-nt, there is a strange message  |
|    |from SCM about mysqld shutdown normally. When run as a service, mysqld-nt has no      |
|    |access to a console and so no messages can be seen.                                   |
|    |On NT you can get the following service error messages:                               |
|    |Permission Denied                                                                     |
|    |Means that it cannot find mysqld-nt.exe                                               |
|    |                                                                                      |
|    |Cannot Register                                                                       |
|    |Means that the path is incorrect                                                      |
|    |                                                                                      |
|    |If you have problems installing mysqld-nt as a service, try starting it with the full |
|    |path:                                                                                 |
|    |                                                                                      |
|    |C:\mysql\bin\mysqld --install                                                         |
|    |If this doesn't work, you can get mysqld-nt to start properly by fixing the path in   |
|    |the registry!                                                                         |
|    |If you don't want to start mysqld-nt as a service, you can start it as follows:       |
|    |                                                                                      |
|    |C:\mysql\bin\mysqld-nt --standalone                                                   |
|    |or                                                                                    |
|    |                                                                                      |
|    |C:\mysql\bin\mysqld-nt --standalone --debug                                           |
|    |The last version gives you a debug trace in `C:\mysqld.trace'.                        |
|    |4.12.4 Faire tourner MySQL sous Win32                                                 |
|    |MySQL supports TCP/IP on all Win32 platforms and named pipes on NT. The default is to |
|    |use named pipes for local connections on NT and TCP/IP for all other cases if the     |
|    |client has TCP/IP installed. The host name specifies which protocol is used:          |
|    |Host name                                                                             |
|    |protocol                                                                              |
|    |                                                                                      |
|    |NULL (none)                                                                           |
|    |On NT, try named pipes first; if that doesn't work, use TCP/IP. On Win95/Win98, TCP/IP|
|    |is used.                                                                              |
|    |                                                                                      |
|    |.                                                                                     |
|    |Named pipes                                                                           |
|    |                                                                                      |
|    |localhost                                                                             |
|    |TCP/IP to current host                                                                |
|    |                                                                                      |
|    |hostname                                                                              |
|    |TCP/IP                                                                                |
|    |                                                                                      |
|    |You can force a MySQL client to use named pipes by specifying the --pipe option. Use  |
|    |the --socket option to specify the name of the pipe.                                  |
|    |You can test whether or not MySQL is working by executing the following commands:     |
|    |                                                                                      |
|    |C:\mysql\bin\mysqlshow                                                                |
|    |C:\mysql\bin\mysqlshow -u root mysql                                                  |
|    |C:\mysql\bin\mysqladmin version status proc                                           |
|    |C:\mysql\bin\mysql test                                                               |
|    |By default, MySQL-Win32 is configured to be installed in `C:\mysql'. If you want to   |
|    |install MySQL elsewhere, install it in `C:\mysql', then move the installation to where|
|    |you want it. If you do move MySQL, you must tell mysqld where everything is by        |
|    |supplying options to mysqld. Use C:\mysql\bin\mysqld --help to display all options!   |
|    |If, for example, you have moved the MySQL distribution to `D:\programs\mysql', you    |
|    |must start mysqld with: D:\programs\mysql\bin\mysqld --basedir D:\programs\mysql      |
|    |With the registered version of MySQL, you can also create a `C:\my.cnf' file that     |
|    |holds any default options for the MySQL server. Copy the file `\mysql\my-example.cnf' |
|    |to `C:\my.cnf' and edit this to suit your setup. Note that you should specify all     |
|    |paths with / instead of \. If you use \, you need to specify this twice, as \ is the  |
|    |escape character in MySQL. 4.15.4 Fichier d'options.                                  |
|    |If mysqld is slow to answer to connections on Win95/Win98, there is probably a problem|
|    |with your DNS. In this case, start mysqld with --skip-name-resolve and use only       |
|    |localhost and IP numbers in the MySQL grant tables. You can also avoid DNS when       |
|    |connecting to a mysqld-nt MySQL server running on NT by using the --pipe argument to  |
|    |specify use of named pipes. This works for most MySQL clients.                        |
|    |There are two versions of the MySQL command line tool:                                |
|    |mysql                                                                                 |
|    |Compiled on native Win32, which offers very limited text editing capabilities.        |
|    |                                                                                      |
|    |mysqlc                                                                                |
|    |Compiled with the Cygnus GNU compiler and libraries, which offers readline editing.   |
|    |                                                                                      |
|    |If you want to use mysqlc.exe, you must copy `C:\mysql\lib\cygwinb19.dll' to          |
|    |`\windows\system' (or similar place).                                                 |
|    |The default privileges on Win32 give all local users full privileges to all databases.|
|    |To make MySQL more secure, you should set a password for all users and remove the row |
|    |in the mysql.user table that has Host='localhost' and User=''.                        |
|    |You should also add a password for the root user:                                     |
|    |                                                                                      |
|    |C:\mysql\bin\mysql mysql                                                              |
|    |mysql> DELETE FROM user WHERE Host='localhost' AND User='';                           |
|    |mysql> QUIT                                                                           |
|    |C:\mysql\bin\mysqladmin reload                                                        |
|    |C:\mysql\bin\mysqladmin -u root password your_password                                |
|    |After you've set the password, if you want to take down the mysqld server, you can do |
|    |so using this command:                                                                |
|    |                                                                                      |
|    |mysqladmin --user=root --password=your_password shutdown                              |
|    |4.12.5 Se connecter à un serveur lointain MySQL avec Win32 et SSH                     |
|    |Here is a note about how to connect to get a secure connection to remote MySQL server |
|    |with SSH (by David Carlson).                                                          |
|    |Install SSH client on your windows machine - I used a free SSH client from            |
|    |http://www.doc.ic.ac.uk/~ci2/ssh/. Other useful links:                                |
|    |http://www.npaci.edu/Security/npaci_security_software.html and                        |
|    |http://www.npaci.edu/Security/samples/ssh32_windows/index.html.                       |
|    |Start SSH. Set Host Name = yourmysqlserver name or IP address. Set userid=your userid |
|    |to log in to your server                                                              |
|    |Click on "local forwards". Set local port: 3306, host: localhost, remote port: 3306   |
|    |Save everything, otherwise you'll have to redo it the next time.                      |
|    |Log in to your server with SSH.                                                       |
|    |Start some ODBC application (for example Access)                                      |
|    |Create a new file and link to mySQL using the ODBC driver the same way you normally do|
|    |except for server, user "localhost".                                                  |
|    |That's it. It works very well with a direct Internet connection. I'm having problems  |
|    |with SSH conflicting with my Win95 network and Wingate - but that'll be the topic of a|
|    |posting on another software company's usegroup!                                       |
|    |4.12.6 MySQL-Win32 comparé à Unix MySQL                                               |
|    |MySQL-Win32 has by now proven itself to be very stable. This version of MySQL has the |
|    |same features as the corresponding Unix version with the following exceptions:        |
|    |Win95 and threads                                                                     |
|    |Win95 leaks about 200 bytes of main memory for each thread creation. Because of this, |
|    |you shouldn't run mysqld for an extended time on Win95 if you do many connections,    |
|    |since each connection in MySQL creates a new thread! WinNT and Win98 don't suffer from|
|    |this bug.                                                                             |
|    |Blocking read                                                                         |
|    |MySQL uses a blocking read for each connection. This means that:                      |
|    |A connection will not be disconnected automatically after 8 hours, as happens with the|
|    |Unix version of MySQL.                                                                |
|    |If a connection ``hangs,'' it's impossible to break it without killing MySQL.         |
|    |mysqladmin kill will not work on a sleeping connection.                               |
|    |mysqladmin shutdown can't abort as long as there are sleeping connections.            |
|    |We plan to fix this in the near future.                                               |
|    |UDF functions                                                                         |
|    |For the moment, MySQL-Win32 does not support user definable functions.                |
|    |DROP DATABASE                                                                         |
|    |You can't drop a database that is in use by some thread.                              |
|    |Killing MySQL from the task manager                                                   |
|    |You can't kill MySQL from the task manager or with the shutdown utility in Windows95. |
|    |You must take it down with mysqladmin shutdown.                                       |
|    |Case-insensitive names                                                                |
|    |Filenames are case insensitive on Win32, so database and table names are also case    |
|    |insensitive in MySQL for Win32. The only restriction is that database and table names |
|    |must be given in the same case throughout a given statement. The following query would|
|    |not work because it refers to a table both as my_table and as MY_TABLE:               |
|    |                                                                                      |
|    |SELECT * FROM my_table WHERE MY_TABLE.col=1;                                          |
|    |The `\' directory character                                                           |
|    |Pathname components in Win95 are separated by `\' characters, which is also the escape|
|    |character in MySQL. If you are using LOAD DATA INFILE or SELECT ... INTO OUTFILE, you |
|    |must double the `\' character or use Unix style filenames `/' characters:             |
|    |                                                                                      |
|    |LOAD DATA INFILE "C:\\tmp\\skr.txt" INTO TABLE skr;                                   |
|    |SELECT * FROM skr INTO OUTFILE 'C:/tmp/skr.txt';                                      |
|    |Can't open named pipe error                                                           |
|    |If you use the shareware version of MySQL-Win32 on NT with the newest mysql-clients   |
|    |you will get the following error:                                                     |
|    |                                                                                      |
|    |error 2017: can't open named pipe to host: . pipe...                                  |
|    |This is because the release version of MySQL uses named pipes on NT by default. You   |
|    |can avoid this error by using the --host=localhost option to the new MySQL clients or |
|    |create a file `C:\my.cnf' that contains the following information:                    |
|    |                                                                                      |
|    |[client]                                                                              |
|    |host = localhost                                                                      |
|    |Access denied for user error                                                          |
|    |If you get the error Access denied for user: 'some-user@unknown' to database 'mysql'  |
|    |when accessing a MySQL server on the same machine, this means that MySQL can't resolve|
|    |your host name properly. To fix this, you should create a file `\windows\hosts' with  |
|    |the following information:                                                            |
|    |                                                                                      |
|    |127.0.0.1       localhost                                                             |
|    |Here are some open issues for anyone who might want to help us with the Win32 release:|
|    |                                                                                      |
|    |Make a single user MYSQL.DLL server. This should include everything in a standard     |
|    |MySQL server, except thread creation. This will make MySQL much easier to use in      |
|    |applications that don't need a true client/server and don't need to access the server |
|    |from other hosts.                                                                     |
|    |Add some nice ``start'' and ``shutdown'' icons to the MySQL installation.             |
|    |Create a tool to manage registry entries for the MySQL startup options. The registry  |
|    |entry reading is already coded into mysqld.cc, but it should be recoded to be more    |
|    |``parameter'' oriented. The tool should also be able to update the `\my.cnf' file if  |
|    |the user would prefer to use this instead of the registry.                            |
|    |When registering mysqld as a service with --install (on NT) it would be nice if you   |
|    |could also add default options on the command line. For the moment, the workaround is |
|    |to update the `C:\my.cnf' file instead.                                               |
|    |When you suspend a laptop running Win95, the mysqld daemon doesn't accept new         |
|    |connections when the laptop is resumed. We don't know if this is a problem with Win95,|
|    |TCP/IP or MySQL.                                                                      |
|    |It would be real nice to be able to kill mysqld from the task manager. For the moment,|
|    |you must use mysqladmin shutdown.                                                     |
|    |Port readline to Win32 for use in the mysql command line tool.                        |
|    |GUI versions of the standard MySQL clients (mysql, mysqlshow, mysqladmin, and         |
|    |mysqldump) would be nice.                                                             |
|    |It would be nice if the socket ``read'' and ``write'' functions in `net.c' were       |
|    |interruptible. This would make it possible to kill open threads with mysqladmin kill  |
|    |on Win32.                                                                             |
|    |Documentation of which Windows programs work with MySQL-Win32/MyODBC and what must be |
|    |done to get them working.                                                             |
|    |mysqld always starts in the "C" locale and not in the default locale. We would like to|
|    |have mysqld use the current locale for the sort order.                                |
|    |Port sqlclient to Win32 (almost done) and add more features to it!                    |
|    |Add more options to MysqlManager.                                                     |
|    |Change the communication protocol between the server and client to use Windows        |
|    |internal communication instead of sockets and TCP/IP.                                 |
|    |Implement UDF functions with .DLLs.                                                   |
|    |Add macros to use the faster thread-safe increment/decrement méthodes provided by     |
|    |Win32.                                                                                |
|    |Other Win32-specific issues are described in the `README' file that comes with the    |
|    |MySQL-Win32 distribution.                                                             |
|    |4.13 Remarques pour OS/2                                                              |
|    |MySQL uses quite a few open files. Because of this, you should add something like the |
|    |following to your `CONFIG.SYS' file:                                                  |
|    |                                                                                      |
|    |SET EMXOPT=-c -n -h1024                                                               |
|    |If you don't do this, you will probably run into the following error:                 |
|    |                                                                                      |
|    |File 'xxxx' not found (Errcode: 24)                                                   |
|    |When using MySQL with OS/2 Warp 3, FixPack 29 or above is required. With OS/2 Warp 4, |
|    |FixPack 4 or above is required. This is a requirement of the Pthreads library. MySQL  |
|    |must be installed in a partition that supports long file names such as HPFS, FAT32,   |
|    |etc.                                                                                  |
|    |The `INSTALL.CMD' script must be run from OS/2's own `CMD.EXE' and may not work with  |
|    |replacement shells such as `4OS2.EXE'.                                                |
|    |The `scripts/mysql-install-db' script has been renamed: it is now called `install.cmd'|
|    |and is a REXX script which will set up the default MySQL security settings and create |
|    |the WorkPlace Shell icons for MySQL.                                                  |
|    |Dynamic module support is compiled in but not fully tested. Dynamic modules should be |
|    |compiled using the Pthreads runtime library.                                          |
|    |                                                                                      |
|    |gcc -Zdll -Zmt -Zcrtdll=pthrdrtl -I../include -I../regex -I.. \                       |
|    |-o example udf_example.cc -L../lib -lmysqlclient udf_example.def                      |
|    |mv example.dll example.udf                                                            |
|    |Note: Due to limitations in OS/2, UDF module name stems must not exceed 8 characters. |
|    |Modules are stored in the `/mysql2/udf' directory; the safe-mysqld.cmd script will put|
|    |this directory in the BEGINLIBPATH environment variable. When using UDF modules,      |
|    |specified extensions are ignored -- it is assumed to be `.udf'. For example, in Unix, |
|    |the shared module might be named `example.so' and you would load a function from it   |
|    |like this:                                                                            |
|    |                                                                                      |
|    |CREATE FUNCTION metaphon RETURNS STRING SONAME "example.so";                          |
|    |Is OS/2, the module would be named `example.udf', but you would not specify the module|
|    |extension:                                                                            |
|    |                                                                                      |
|    |CREATE FUNCTION metaphon RETURNS STRING SONAME "example";                             |
|    |4.14 TcX                                                                              |
|    |As a service, TcX provides a set of binary distributions of MySQL that are compiled at|
|    |TcX or at sites where customers kindly have given us access to their machines.        |
|    |These distributions are generated with scripts/make_binary_distribution and are       |
|    |configured with the following compilers and options:                                  |
|    |SunOS 4.1.4 2 sun4c with gcc 2.7.2.1                                                  |
|    |CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql --disable-shared    |
|    |SunOS 5.5.1 sun4u with egcs 1.0.3a                                                    |
|    |CC=gcc CFLAGS="-O6 -fomit-frame-pointer" CXX=gcc CXXFLAGS="-O6 -fomit-frame-pointer   |
|    |-felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql |
|    |--with-low-memory                                                                     |
|    |SunOS 5.6 sun4u with egcs 2.90.27                                                     |
|    |CC=gcc CFLAGS="-O6 -fomit-frame-pointer" CXX=gcc CXXFLAGS="-O6 -fomit-frame-pointer   |
|    |-felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql |
|    |--with-low-memory                                                                     |
|    |SunOS 5.6 i86pc with gcc 2.8.1                                                        |
|    |CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql --with-low-memory   |
|    |Linux 2.0.33 i386 with pgcc 2.90.29 (egcs 1.0.3a)                                     |
|    |CFLAGS="-O6 -mpentium -mstack-align-double -fomit-frame-pointer" CXX=gcc CXXFLAGS="-O6|
|    |-mpentium -mstack-align-double -fomit-frame-pointer -felide-constructors              |
|    |-fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --enable-assembler   |
|    |--with-mysqld-ldflags=-all-static                                                     |
|    |SCO 3.2v5.0.4 i386 with gcc 2.7-95q4                                                  |
|    |CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql                     |
|    |AIX 2 4 with gcc 2.7.2.2                                                              |
|    |CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql                     |
|    |OSF1 V4.0 564 alpha with gcc 2.8.1                                                    |
|    |CC=gcc CFLAGS=-O CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql           |
|    |--with-low-memory                                                                     |
|    |Irix 6.3 IP32 with gcc 2.8.0                                                          |
|    |CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql                     |
|    |BSDI BSD/OS 3.1 i386 with gcc 2.7.2.1                                                 |
|    |CC=gcc CXX=gcc CXXFLAGS=-O ./configure --prefix=/usr/local/mysql                      |
|    |BSDI BSD/OS 2.1 i386 with gcc 2.7.2                                                   |
|    |CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql                     |
|    |Anyone who has more optimal options for any of the configurations listed above can    |
|    |always mail them to the developer's mailing list at                                   |
|    |RPM distributions prior to MySQL 3.22 are user-contributed. Beginning with 3.22, some |
|    |RPMs are TcX-generated.                                                               |
|    |4.15 Paramètrage post-installation et tests                                           |
|    |Once you've installed MySQL (from either a binary or source distribution), you need to|
|    |initialize the grant tables, start the server and make sure that the server works     |
|    |okay. You may also wish to arrange for the server to be started and stopped           |
|    |automatically when your system starts up and shuts down.                              |
|    |Normally you install the grant tables and start the server like this:                 |
|    |                                                                                      |
|    |shell> cd mysql_installation_directory                                                |
|    |shell> ./bin/mysql_install_db                                                         |
|    |shell> ./bin/safe_mysqld &                                                            |
|    |Testing is most easily done from the top-level directory of the MySQL distribution.   |
|    |For a binary distribution, this is your installation directory (typically something   |
|    |like `/usr/local/mysql'). For a source distribution, this is the main directory of    |
|    |your MySQL source tree.                                                               |
|    |In the commands shown below in this section and in the following subsections, BINDIR  |
|    |is the path to the location in which programs like mysqladmin and safe_mysqld are     |
|    |installed. For a binary distribution, this is the `bin' directory within the          |
|    |distribution. For a source distribution, BINDIR is probably `/usr/local/bin', unless  |
|    |you specified an installation directory other than `/usr/local' when you ran          |
|    |configure. EXECDIR is the location in which the mysqld server is installed. For a     |
|    |binary distribution, this is the same as BINDIR. For a source distribution, EXECDIR is|
|    |probably `/usr/local/libexec'.                                                        |
|    |Testing is described in detail below:                                                 |
|    |If necessary, start the mysqld server and set up the initial MySQL grant tables       |
|    |containing the privileges that determine how users are allowed to connect to the      |
|    |server. This is normally done with the mysql_install_db script:                       |
|    |                                                                                      |
|    |shell> scripts/mysql_install_db                                                       |
|    |Typically, mysql_install_db needs to be run only the first time you install MySQL.    |
|    |Therefore, if you are upgrading an existing installation, you can skip this step.     |
|    |(However, mysql_install_db is quite safe to use and will not update any tables that   |
|    |already exist, so if you are unsure what to do, you can always run mysql_install_db.) |
|    |mysql_install_db creates six tables (user, db, host, tables_priv, columns_priv and    |
|    |func) in the mysql database. A description of the initial privileges is given in 6.10 |
|    |Droits initiaux. Briefly, these privileges allow the MySQL root user to do anything,  |
|    |and allow anybody to create or use databases with a name of 'test' or starting with   |
|    |'test_'. If you don't set up the grant tables, the following error will appear in the |
|    |log file when you start the server:                                                   |
|    |                                                                                      |
|    |mysqld: Can't find file: 'host.frm'                                                   |
|    |The above may also happens with a binary MySQL distribution if you don't start MySQL  |
|    |by executing exactly ./bin/safe_mysqld! You might need to run mysql_install_db as     |
|    |root. However, if you prefer, you can run the MySQL server as an unprivileged         |
|    |(non-root) user, provided that user can read and write files in the database          |
|    |directory. Instructions for running MySQL as an unprivileged user are given in        |
|    |Changing MySQL user. If you have problems with mysql_install_db, see mysql_install_db.|
|    |There are some alternatives to running the mysql_install_db script as it is provided  |
|    |in the MySQL distribution:                                                            |
|    |You may want to edit mysql_install_db before running it, to change the initial        |
|    |privileges that are installed into the grant tables. This is useful if you want to    |
|    |install MySQL on a lot of machines with the same privileges. In this case you probably|
|    |should need only to add a few extra INSERT statements to the mysql.user and mysql.db  |
|    |tables!                                                                               |
|    |If you want to change things in the grant tables after installing them, you can run   |
|    |mysql_install_db, then use mysql -u root mysql to connect to the grant tables as the  |
|    |MySQL root user and issue SQL statements to modify the grant tables directly.         |
|    |It is possible to recreate the grant tables completely after they have already been   |
|    |created. You might want to do this if you've already installed the tables but then    |
|    |want to recreate them after editing mysql_install_db.                                 |
|    |For more information about these alternatives, see 6.10 Droits initiaux.              |
|    |Start the MySQL server like this:                                                     |
|    |                                                                                      |
|    |shell> cd mysql_installation_directory                                                |
|    |shell> bin/safe_mysqld &                                                              |
|    |If you have problems starting the server, see 4.15.2 Problèmes avec le serveur MySQL. |
|    |Use mysqladmin to verify that the server is running. The following commands provide a |
|    |simple test to check that the server is up and responding to connections:             |
|    |                                                                                      |
|    |shell> BINDIR/mysqladmin version                                                      |
|    |shell> BINDIR/mysqladmin variables                                                    |
|    |The output from mysqladmin version varies slightly depending on your platform and     |
|    |version of MySQL, but should be similar to that shown below:                          |
|    |                                                                                      |
|    |shell> BINDIR/mysqladmin version                                                      |
|    |mysqladmin  Ver 6.3 Distrib 3.22.9-beta, for pc-linux-gnu on i686                     |
|    |TCX Datakonsult AB, by Monty                                                          |
|    |                                                                                      |
|    |Server version          3.22.9-beta                                                   |
|    |Protocol version        10                                                            |
|    |Connection              Localhost via UNIX socket                                     |
|    |TCP port                3306                                                          |
|    |UNIX socket             /tmp/mysql.sock                                               |
|    |Uptime:                 16 sec                                                        |
|    |                                                                                      |
|    |Running threads: 1  Questions: 20  Reloads: 2  Open tables: 3                         |
|    |To get a feeling for what else you can do with BINDIR/mysqladmin, invoke it with the  |
|    |--help option.                                                                        |
|    |Verify that you can shut down the server:                                             |
|    |                                                                                      |
|    |shell> BINDIR/mysqladmin -u root shutdown                                             |
|    |Verify that you can restart the server. Do this using safe_mysqld or by invoking      |
|    |mysqld directly. For example:                                                         |
|    |                                                                                      |
|    |shell> BINDIR/safe_mysqld --log &                                                     |
|    |If safe_mysqld fails, try running it from the MySQL installation directory (if you are|
|    |not already there). If that doesn't work, see 4.15.2 Problèmes avec le serveur MySQL. |
|    |Run some simple tests to verify that the server is working. The output should be      |
|    |similar to what is shown below:                                                       |
|    |                                                                                      |
|    |shell> BINDIR/mysqlshow                                                               |
|    |+-----------+                                                                         |
|    || Databases |                                                                         |
|    |+-----------+                                                                         |
|    || mysql     |                                                                         |
|    |+-----------+                                                                         |
|    |                                                                                      |
|    |shell> BINDIR/mysqlshow mysql                                                         |
|    |Database: mysql                                                                       |
|    |+--------------+                                                                      |
|    ||    Tables    |                                                                      |
|    |+--------------+                                                                      |
|    || columns_priv |                                                                      |
|    || db           |                                                                      |
|    || func         |                                                                      |
|    || host         |                                                                      |
|    || tables_priv  |                                                                      |
|    || user         |                                                                      |
|    |+--------------+                                                                      |
|    |                                                                                      |
|    |shell> BINDIR/mysql -e "select host,db,user from db" mysql                            |
|    |+------+--------+------+                                                              |
|    || host | db     | user |                                                              |
|    |+------+--------+------+                                                              |
|    || %    | test   |      |                                                              |
|    || %    | test_% |      |                                                              |
|    |+------+--------+------+                                                              |
|    |There is also a benchmark suite in the `sql-bench' directory (under the MySQL         |
|    |installation directory) that you can use to compare how MySQL performs on different   |
|    |platforms. The `sql-bench/Results' directory contains the results from many runs      |
|    |against different databases and platforms. To run all tests, execute these commands:  |
|    |                                                                                      |
|    |shell> cd sql-bench                                                                   |
|    |shell> run-all-tests                                                                  |
|    |If you don't have the `sql-bench' directory, you are probably using an RPM for a      |
|    |binary distribution. (Source distribution RPMs include the benchmark directory.) In   |
|    |this case, you must first install the benchmark suite before you can use it. Beginning|
|    |with MySQL 3.22, there are benchmark RPM files named `mysql-bench-VERSION-i386.rpm'   |
|    |that contain benchmark code and data. If you have a source distribution, you can also |
|    |run the tests in the `tests' subdirectory. For example, to run `auto_increment.tst',  |
|    |do this:                                                                              |
|    |                                                                                      |
|    |shell> BINDIR/mysql -vvf test < ./tests/auto_increment.tst                            |
|    |The expected results are shown in the `./tests/auto_increment.res' file.              |
|    |4.15.1 Problèmes avec mysql_install_db                                                |
|    |This section lists problems you might encounter when you run mysql_install_db:        |
|    |mysql_install_db doesn't install the grant tables                                     |
|    |You may find that mysql_install_db fails to install the grant tables and terminates   |
|    |after displaying the following messages:                                              |
|    |                                                                                      |
|    |starting mysqld daemon with databases from XXXXXX                                     |
|    |mysql daemon ended                                                                    |
|    |In this case, you should examine the log file very carefully! The log should be       |
|    |located in the directory `XXXXXX' named by the error message, and should indicate why |
|    |mysqld didn't start. If you don't understand what happened, include the log when you  |
|    |post a bug report using mysqlbug! 2.3 Comment rapporter des bugs et des problèmes.    |
|    |There is already a mysqld daemon running                                              |
|    |In this case, you have probably don't have to run mysql_install_db at all. You have to|
|    |run mysql_install_db only once, when you install MySQL the first time.                |
|    |Installing a second mysqld daemon doesn't work when one daemon is running             |
|    |This can happen when you already have an existing MySQL installation, but want to put |
|    |a new installation in a different place (e.g., for testing, or perhaps you simply want|
|    |to run two installations at the same time). Generally the problem that occurs when you|
|    |try to run the second server is that it tries to use the same socket and port as the  |
|    |old one. In this case you will get the error message: Can't start server: Bind on     |
|    |TCP/IP port: Address already in use or Can't start server : Bind on unix socket... You|
|    |can start the new server with a different socket and port as follows:                 |
|    |                                                                                      |
|    |shell> MYSQL_UNIX_PORT=/tmp/mysqld-new.sock                                           |
|    |shell> MYSQL_TCP_PORT=3307                                                            |
|    |shell> export MYSQL_UNIX_PORT MYSQL_TCP_PORT                                          |
|    |shell> scripts/mysql_install_db                                                       |
|    |shell> bin/safe_mysqld &                                                              |
|    |After this, you should edit your server boot script to start both daemons with        |
|    |different sockets and ports. For example, it could invoke safe_mysqld twice, but with |
|    |different --socket, --port and --basedir options for each invocation.                 |
|    |You don't have write access to `/tmp'                                                 |
|    |If you don't have write access to create a socket file at the default place (in       |
|    |`/tmp') or permission to create temporary files in `/tmp,' you will get an error when |
|    |running mysql_install_db or when starting or using mysqld. You can specify a different|
|    |socket and temporary directory as follows:                                            |
|    |                                                                                      |
|    |shell> TMPDIR=/some_tmp_dir/                                                          |
|    |shell> MYSQL_UNIX_PORT=/some_tmp_dir/mysqld.sock                                      |
|    |shell> export TMPDIR MYSQL_UNIX_PORT                                                  |
|    |`some_tmp_dir' should be the path to some directory for which you have write          |
|    |permission. After this you should be able to run mysql_install_db and start the server|
|    |with these commands:                                                                  |
|    |                                                                                      |
|    |shell> scripts/mysql_install_db                                                       |
|    |shell> BINDIR/safe_mysqld &                                                           |
|    |mysqld crashes immediately                                                            |
|    |If you are running RedHat 5.0 with a version of glibc older than 2.0.7-5, you should  |
|    |make sure you have installed all glibc patches! There is a lot of information about   |
|    |this in the MySQL mail archives. Links to the mail archives are available at the      |
|    |online MySQL documentation page. Also, see 4.11.5 Linux (Toutes versions de Linux).   |
|    |You can also start mysqld manually using the --skip-grant option and add the privilege|
|    |information yourself using mysql:                                                     |
|    |                                                                                      |
|    |shell> BINDIR/safe_mysqld --skip-grant &                                              |
|    |shell> BINDIR/mysql -u root mysql                                                     |
|    |From mysql, manually execute the SQL commands in mysql_install_db. Make sure you run  |
|    |mysqladmin reload afterward to tell the server to reload the grant tables.            |
|    |4.15.2 Problèmes avec le serveur MySQL                                                |
|    |Generally, you start the mysqld server in one of three ways:                          |
|    |By invoking mysql.server. This script is used primarily at system startup and         |
|    |shutdown, and is described more fully in 4.15.3 Démarrer et arrête MySQL              |
|    |automatiquement.                                                                      |
|    |By invoking safe_mysqld, which tries to determine the proper options for mysqld and   |
|    |then runs it with those options.                                                      |
|    |By invoking mysqld directly.                                                          |
|    |Whichever méthode you use to start the server, if it fails to start up correctly,     |
|    |check the log file to see if you can find out why. Log files are located in the data  |
|    |directory (typically `/usr/local/mysql/data' for a binary distribution,               |
|    |`/usr/local/var' for a source distribution). Look in the data directory for files with|
|    |names of the form `host_name.err' and `host_name.log' where host_name is the name of  |
|    |your server host. Then check the last few lines of these files:                       |
|    |                                                                                      |
|    |shell> tail host_name.err                                                             |
|    |shell> tail host_name.log                                                             |
|    |When the mysqld daemon starts up, it changes directory to the data directory. This is |
|    |where it expects to write log files and the pid (process ID) file, and where it       |
|    |expects to find databases.                                                            |
|    |The data directory location is hardwired in when the distribution is compiled.        |
|    |However, if mysqld expects to find the data directory somewhere other than where it   |
|    |really is on your system, it will not work properly. If you have problems with        |
|    |incorrect paths, you can find out what options mysqld allows and what the default path|
|    |settings are by invoking mysqld with the --help option. You can override the defaults |
|    |by specifying the correct pathnames as command-line arguments to mysqld. (These       |
|    |options can be used with safe_mysqld as well.)                                        |
|    |Normally you should need to tell mysqld only the base directory under which MySQL is  |
|    |installed. You can do this with the --basedir option. You can also use --help to check|
|    |the effect of changing path options (note that --help must be the final option of the |
|    |mysqld command). For example:                                                         |
|    |                                                                                      |
|    |shell> EXECDIR/mysqld --basedir=/usr/local --help                                     |
|    |Once you determine the path settings you want, start the server without the --help    |
|    |option.                                                                               |
|    |If you get the following error, it means that some other program (or another mysqld   |
|    |server) is already using the TCP/IP port or socket mysqld is trying to use:           |
|    |                                                                                      |
|    |Can't start server: Bind on TCP/IP port: Address already in use                       |
|    |or                                                                                    |
|    |Can't start server : Bind on unix socket...                                           |
|    |Use ps to make sure that you don't have another mysqld server running. If you can't   |
|    |find another server running, you can try to execute the command telnet your-host-name |
|    |tcp-ip-port-number and press RETURN a couple of times. If you don't get a error       |
|    |message like telnet: Unable to connect to remote host: Connection refused, something  |
|    |is using the TCP/IP port mysqld is trying to use. mysql_install_db, and 19.3 Faire    |
|    |tourner plusieurs serveurs MySQL sur la même machine.                                 |
|    |The safe_mysqld script is written so that it normally is able to start a server that  |
|    |was installed from either a source or a binary version of MySQL, even if these install|
|    |the server in slightly different locations. safe_mysqld expects one of these          |
|    |conditions to be true:                                                                |
|    |The server and databases can be found relative to the directory from which safe_mysqld|
|    |is invoked. safe_mysqld looks under its working directory for `bin' and `data'        |
|    |directories (for binary distributions) or for `libexec' and `var' directories (for    |
|    |source distributions). This condition should be met if you execute safe_mysqld from   |
|    |your MySQL installation directory (for example, `/usr/local/mysql' for a binary       |
|    |distribution).                                                                        |
|    |If the server and databases cannot be found relative to its working directory,        |
|    |safe_mysqld attempts to locate them by absolute pathnames. Typical locations are      |
|    |`/usr/local/libexec' and `/usr/local/var'. The actual locations are determined when   |
|    |the distribution was built from which safe_mysqld comes. They should be correct if    |
|    |MySQL was installed in a standard location.                                           |
|    |Since safe_mysqld will try to find the server and databases relative to its own       |
|    |working directory, you can install a binary distribution of MySQL anywhere, as long as|
|    |you start safe_mysqld from the MySQL installation directory:                          |
|    |                                                                                      |
|    |shell> cd mysql_installation_directory                                                |
|    |shell> bin/safe_mysqld &                                                              |
|    |If safe_mysqld fails, even when invoked from the MySQL installation directory, you can|
|    |modify it to use the path to mysqld and the pathname options that are correct for your|
|    |system. Note that if you upgrade MySQL in the future, your modified version of        |
|    |safe_mysqld will be overwritten, so you should make a copy of your edited version that|
|    |you can reinstall.                                                                    |
|    |If mysqld is currently running, you can find out what path settings it is using by    |
|    |executing this command:                                                               |
|    |                                                                                      |
|    |shell> mysqladmin variables                                                           |
|    |                                                                                      |
|    |or                                                                                    |
|    |                                                                                      |
|    |shell> mysqladmin -h 'your-host-name' variables                                       |
|    |If safe_mysqld starts the server but you can't connect to it, you should make sure you|
|    |have an entry in `/etc/hosts' that looks like this:                                   |
|    |                                                                                      |
|    |127.0.0.1       localhost                                                             |
|    |This problem occurs only on systems that don't have a working thread library and for  |
|    |which MySQL must be configured to use MIT-pthreads.                                   |
|    |4.15.3 Démarrer et arrête MySQL automatiquement                                       |
|    |The mysql.server script can be used to start or stop the server, by invoking it with  |
|    |start or stop arguments:                                                              |
|    |                                                                                      |
|    |shell> mysql.server start                                                             |
|    |shell> mysql.server stop                                                              |
|    |mysql.server can be found in the `share/mysql' directory under the MySQL installation |
|    |directory, or in the `support-files' directory of the MySQL source tree.              |
|    |Before mysql.server starts the server, it changes directory to the MySQL installation |
|    |directory, then invokes safe_mysqld. You might need to edit mysql.server if you have a|
|    |binary distribution that you've installed in a non-standard location. Modify it to cd |
|    |into the proper directory before it runs safe_mysqld. If you want the server to run as|
|    |some specific user, you can change the mysql_daemon_user=root line to use another     |
|    |user. You can also modify mysql.server to pass other options to safe_mysqld.          |
|    |mysql.server stop brings down server by sending a signal to it. You can take down the |
|    |server manually by executing mysqladmin shutdown.                                     |
|    |You might want to add these start and stop commands to the appropriate places in your |
|    |`/etc/rc*' files when you start using MySQL for production applications. Note that if |
|    |you modify mysql.server, then if you upgrade MySQL sometime, your modified version    |
|    |will be overwritten, so you should make a copy of your edited version that you can    |
|    |reinstall.                                                                            |
|    |If your system uses `/etc/rc.local' to start external scripts, you should append the  |
|    |following to it:                                                                      |
|    |                                                                                      |
|    |/bin/sh -c 'cd /usr/local/mysql ; ./bin/safe_mysqld &'                                |
|    |You can also add options or mysql.server in a global `/etc/my.cnf' file. A typical    |
|    |`/etc/my.cnf' file might look like this:                                              |
|    |                                                                                      |
|    |[mysqld]                                                                              |
|    |datadir=/usr/local/mysql/var                                                          |
|    |socket=/tmp/mysqld.sock                                                               |
|    |port=3306                                                                             |
|    |                                                                                      |
|    |[mysql.server]                                                                        |
|    |user=mysql                                                                            |
|    |basedir=/usr/local/mysql                                                              |
|    |The mysql.server script uses the following variables: user, datadir, basedir, bindir  |
|    |and pid-file.                                                                         |
|    |4.15.4 Fichier d'options.                                                             |
|    |4.15.4 Fichier d'options                                                              |
|    |MySQL 3.22 can read default startup options for the server and for clients from option|
|    |files.                                                                                |
|    |MySQL reads default options from the following files on Unix:                         |
|    |Filename                                                                              |
|    |Purpose                                                                               |
|    |                                                                                      |
|    |/etc/my.cnf                                                                           |
|    |Global options                                                                        |
|    |                                                                                      |
|    |DATADIR/my.cnf                                                                        |
|    |Server-specific options                                                               |
|    |                                                                                      |
|    |~/.my.cnf                                                                             |
|    |User-specific options                                                                 |
|    |                                                                                      |
|    |DATADIR is the MySQL data directory (typically `/usr/local/mysql/data' for a binary   |
|    |installation, or `/usr/local/var' for a source installation). Note that this is the   |
|    |directory that was specified at configuration time, not the one specified with        |
|    |--datadir when mysqld starts up! (--datadir has no effect on where the server looks   |
|    |for option files, because it looks for them before it processes any command-line      |
|    |arguments.)                                                                           |
|    |MySQL reads default options from the following files on Win32:                        |
|    |Filename                                                                              |
|    |Purpose                                                                               |
|    |                                                                                      |
|    |windows-system-directory\my.ini                                                       |
|    |                                                                                      |
|    |                                                                                      |
|    |C:\my.cnf                                                                             |
|    |Global options                                                                        |
|    |                                                                                      |
|    |C:\mysql\data\my.cnf                                                                  |
|    |Server-specific options                                                               |
|    |                                                                                      |
|    |Note that you on Win32 should specify all paths with / instead of \. If you use \, you|
|    |need to specify this twice, as \ is the escape character in MySQL.                    |
|    |MySQL tries to read option files in the order listed above. If multiple option files  |
|    |exist, an option specified in a file read later takes precedence over the same option |
|    |specified in a file read earlier. Options specified on the command line take          |
|    |precedence over options specified in any option file. Some options can be specified   |
|    |using environment variables. Options specified on the command line or in option files |
|    |take precedence over environment variable values.                                     |
|    |The following programs support option files: mysql, mysqladmin, mysqld, mysqldump,    |
|    |mysqlimport, mysql.server, isamchk and pack_isam.                                     |
|    |You can use option files to specify any long option that a program supports! Run the  |
|    |program with --help to get a list of available options.                               |
|    |An option file can contain lines of the following forms:                              |
|    |#comment                                                                              |
|    |Comment lines starts with `#' or `;'. Empty lines are ignored.                        |
|    |[group]                                                                               |
|    |group is the name of the program or group for which you want to set options. After a  |
|    |group line, any option or set-variable lines apply to the named group until the end of|
|    |the option file or another group line is given.                                       |
|    |option                                                                                |
|    |This is equivalent to --option on the command line.                                   |
|    |option=value                                                                          |
|    |This is equivalent to --option=value on the command line.                             |
|    |set-variable = variable=value                                                         |
|    |This is equivalent to --set-variable variable=value on the command line. This syntax  |
|    |must be used to set a mysqld variable.                                                |
|    |The client group allows you to specify options that apply to all MySQL clients (not   |
|    |mysqld). This is the perfect group to use to specify the password you use to connect  |
|    |to the server. (But make sure the option file is readable and writable only to        |
|    |yourself.)                                                                            |
|    |Note that for options and values, all leading and trailing blanks are automatically   |
|    |deleted. You may use the escape sequences `\b', `\t', `\n', `\r', `\\' and `\s' in    |
|    |your value string (`\s' == blank).                                                    |
|    |Here is a typical global option file:                                                 |
|    |                                                                                      |
|    |[client]                                                                              |
|    |port=3306                                                                             |
|    |socket=/tmp/mysql.sock                                                                |
|    |                                                                                      |
|    |[mysqld]                                                                              |
|    |port=3306                                                                             |
|    |socket=/tmp/mysql.sock                                                                |
|    |set-variable = key_buffer=16M                                                         |
|    |set-variable = max_allowed_packet=1M                                                  |
|    |                                                                                      |
|    |[mysqldump]                                                                           |
|    |quick                                                                                 |
|    |Here is typical user option file:                                                     |
|    |                                                                                      |
|    |[client]                                                                              |
|    |# The following password will be sent to all standard MySQL clients                   |
|    |password=my_password                                                                  |
|    |                                                                                      |
|    |[mysql]                                                                               |
|    |no-auto-rehash                                                                        |
|    |If you have a source distribution, you will find a sample configuration file named    |
|    |`my-example.cnf' in the `support-files' directory. If you have a binary distribution, |
|    |look in the `DIR/share/mysql' directory, where DIR is the pathname to the MySQL       |
|    |installation directory (typically `/usr/local/mysql'). You can copy `my-example.cnf'  |
|    |to your home directory (rename the copy to `.my.cnf') to experiment with.             |
|    |To tell a MySQL program not to read any option files, specify --no-defaults as the    |
|    |first option on the command line. This MUST be the first option or it will have no    |
|    |effect! If you want to check which options are used, you can give the option          |
|    |--print-defaults as the first option.                                                 |
|    |If you want to force the use of a specific config file, you can use the option        |
|    |--defaults-file=full-path-to-default-file. If you do this, only the specified file    |
|    |will be read.                                                                         |
|    |Note for developers: Option file handling is implemented simply by processing all     |
|    |matching options (i.e., options in the appropriate group) before any command line     |
|    |arguments. This works nicely for programs that use the last instance of an option that|
|    |is specified multiple times. If you have an old program that handles                  |
|    |multiply-specified options this way but doesn't read option files, you need add only  |
|    |two lines to give it that capability. Check the source code of any of the standard    |
|    |MySQL clients to see how to do this.                                                  |
|    |4.16 Y a t il des manipulations particulières lors de la mise à jour?                 |
|    |You can always move the MySQL form and data files between different versions on the   |
|    |same architecture as long as you have the same base version of MySQL. The current base|
|    |version is 3. If you change the character set by recompiling MySQL (which may also    |
|    |change the sort order), you must run isamchk -r -q on all tables. Otherwise your      |
|    |indexes may not be ordered correctly.                                                 |
|    |If you are paranoid and/or afraid of new versions, you can always rename your old     |
|    |mysqld to something like mysqld-'old-version-number'. If your new mysqld then does    |
|    |something unexpected, you can simply shut it down and restart with your old mysqld!   |
|    |When you do an upgrade you should also backup your old databases, of course. Sometimes|
|    |it's good to be a little paranoid!                                                    |
|    |After an upgrade, if you experience problems with recompiled client programs, like    |
|    |Commands out of sync or unexpected core dumps, you probably have used an old header or|
|    |library file when compiling your programs. In this case you should check the date for |
|    |your `mysql.h' file and `libmysqlclient.a' library to verify that they are from the   |
|    |new MySQL distribution. If not, please recompile your programs!                       |
|    |If you get some problems that the new mysqld server doesn't want to start or that you |
|    |can't connect without a password, check that you don't have some old `my.cnf' file    |
|    |from your old installation! You can check this with: program-name --print-defaults. If|
|    |this outputs anything other than the program name, you have a active my.cnf file that |
|    |will may affect things!                                                               |
|    |It is a good idea to rebuild and reinstall the Msql-Mysql-modules distribution        |
|    |whenever you install a new release of MySQL, particularly if you notice symptoms such |
|    |as all your DBI scripts dumping core after you upgrade MySQL.                         |
|    |4.16.1 Mise à jour de a 3.22 vers 3.23                                                |
|    |MySQL 3.23 supports tables of the new MyISAM type and the old NISAM type. You don't   |
|    |have to convert your old tables to use these with 3.23. By default, all new tables    |
|    |will be created with type MyISAM (unless you start mysqld with the                    |
|    |--default-table-type=isam option. You can change an ISAM table to a MyISAM table with |
|    |ALTER TABLE or the Perl script mysql_convert_table_format.                            |
|    |3.22 and 3.21 clients will work without any problems with a 3.23 server.              |
|    |The following lists what you have to watch out for when upgrading to 3.23:            |
|    |INNER and DELAYED are now reserved words.                                             |
|    |FLOAT(4) and FLOAT(8) are now true floating point types.                              |
|    |When declaring DECIMAL(length,dec) the length argument no longer includes a place for |
|    |the sign or the decimal point.                                                        |
|    |A TIME string must now be of one of the following formats: [[[DAYS]                   |
|    |[H]H:]MM:]SS[.fraction] or [[[[[H]H]H]H]MM]SS[.fraction]                              |
|    |LIKE now compares strings using the same character comparison rules as '='. If you    |
|    |require the old behavior, you can compile MySQL with the CXXFLAGS=-DLIKE_CMP_TOUPPER  |
|    |flag.                                                                                 |
|    |When you check/repair tables you should use myisamchk for MyISAM tables (.MYI) and    |
|    |isamchk for ISAM (.ISM) tables.                                                       |
|    |If you want your mysqldumps to be compatible between MySQL 3.22 and 3.23, you should  |
|    |not use the --opt or --full option to mysqldump.                                      |
|    |Check all your calls to DATE_FORMAT() to make sure there is a `%' before each format  |
|    |character.                                                                            |
|    |mysql_fetch_fields_direct is now a function (it was a macro) and it returns a pointer |
|    |to a MYSQL_FIELD instead of a MYSQL_FIELD.                                            |
|    |mysql_num_fields() can no longer be used on a MYSQL* object (it's now a function that |
|    |takes MYSQL_RES* as an argument. You should now use mysql_field_count() instead.      |
|    |In MySQL 3.22, the output of SELECT DISTINCT ... was almost always sorted. In 3.23,   |
|    |you must use GROUP BY or ORDER BY to obtain sorted output.                            |
|    |SUM() now returns NULL, instead of 0, if there is no matching rows. This is according |
|    |to ANSI SQL.                                                                          |
|    |New restricted words: CASE, THEN, WHEN, ELSE and END                                  |
|    |4.16.2 Mise à jour de a 3.21 vers 3.22                                                |
|    |Nothing that affects compatibility has changed between 3.21 and 3.22. The only pitfall|
|    |is that new tables that are created with DATE type columns will use the new way to    |
|    |store the date. You can't access these new fields from an old version of mysqld.      |
|    |After installing MySQL 3.22, you should start the new server and then run the         |
|    |mysql_fix_privilege_tables script. This will add the new privileges that you need to  |
|    |use the GRANT command. If you forget this, you will get Access denied when you try to |
|    |use ALTER TABLE, CREATE INDEX or DROP INDEX. If your MySQL root user requires a       |
|    |password, you should give this as an argument to mysql_fix_privilege_tables.          |
|    |The C API interface to mysql_real_connect() has changed. If you have an old client    |
|    |program that calls this function, you must place a 0 for the new db argument (or      |
|    |recode the client to send the db element for faster connections). You must also call  |
|    |mysql_init() before calling mysql_real_connect()! This change was done to allow the   |
|    |new mysql_options() function to save options in the MYSQL handler structure.          |
|    |4.16.3 Mise à jour de a 3.20 vers 3.21                                                |
|    |If you are running a version older than 3.20.28 and want to switch to 3.21.x, you need|
|    |to do the following:                                                                  |
|    |You can start the mysqld 3.21 server with safe_mysqld --old-protocol to use it with   |
|    |clients from the 3.20 distribution. In this case, the new client function             |
|    |mysql_errno() will not return any server error, only CR_UNKNOWN_ERROR, (but it works  |
|    |for client errors) and the server uses the old password() checking rather than the new|
|    |one.                                                                                  |
|    |If you are NOT using the --old-protocol option to mysqld, you will need to make the   |
|    |following changes:                                                                    |
|    |All client code must be recompiled. If you are using ODBC, you must get the new MyODBC|
|    |2.x driver.                                                                           |
|    |The script scripts/add_long_password must be run to convert the Password field in the |
|    |mysql.user table to CHAR(16).                                                         |
|    |All passwords must be reassigned in the mysql.user table (to get 62-bit rather than   |
|    |31-bit passwords).                                                                    |
|    |The table format hasn't changed, so you don't have to convert any tables.             |
|    |MySQL 3.20.28 and above can handle the new user table format without affecting        |
|    |clients. If you have a MySQL version earlier than 3.20.28, passwords will no longer   |
|    |work with it if you convert the user table. So to be safe, you should first upgrade to|
|    |at least 3.20.28 and then upgrade to 3.21.x.                                          |
|    |The new client code works with a 3.20.x mysqld server, so if you experience problems  |
|    |with 3.21.x, you can use the old 3.20.x server without having to recompile the clients|
|    |again.                                                                                |
|    |If you are not using the --old-protocol option to mysqld, old clients will issue the  |
|    |error message:                                                                        |
|    |                                                                                      |
|    |ERROR: Protocol mismatch. Server Version = 10 Client Version = 9                      |
|    |The new Perl DBI/DBD interface also supports the old mysqlperl interface. The only    |
|    |change you have to make if you use mysqlperl is to change the arguments to the        |
|    |connect() function. The new arguments are: host, database, user, password (the user   |
|    |and password arguments have changed places). Perl DBI Class.                          |
|    |The following changes may affect requêtesin old applications:                         |
|    |HAVING must now be specified before any ORDER BY clause.                              |
|    |The parameters to LOCATE() have been swapped.                                         |
|    |There are some new reserved words. The most notable are DATE, TIME and TIMESTAMP.     |
|    |4.16.4 Mise à jour vers une autre architecture                                        |
|    |If you are using MySQL 3.23, you can copy the .frm, the .MYI and the .MYD files       |
|    |between different architectures that support the same floating point format. (MySQL   |
|    |takes care of any byte swapping issues).                                              |
|    |The MySQL data `*.ISD' and the index files `*.ISM' files) are architecture-dependent  |
|    |and in some case OS-dependent. If you want to move your applications to another       |
|    |machine that has a different architecture or OS than your current machine, you should |
|    |not try to move a database by simply copying the files to the other machine. Use      |
|    |mysqldump instead.                                                                    |
|    |By default, mysqldump will create a file full of SQL statements. You can then transfer|
|    |the file to the other machine and feed it as input to the mysql client.               |
|    |Try mysqldump --help to see what options are available. If you are moving the data to |
|    |a newer version of MySQL, you should use mysqldump --opt with the newer version to get|
|    |a fast, compact dump.                                                                 |
|    |The easiest (although not the fastest) way to move a database between two machines is |
|    |to run the following commands on the machine on which the database is located:        |
|    |                                                                                      |
|    |shell> mysqladmin -h 'other hostname' create nom_base_de_donnees                      |
|    |shell> mysqldump --opt nom_base_de_donnees \                                          |
|    || mysql -h 'other hostname' nom_base_de_donnees                                       |
|    |If you want to copy a database from a remote machine over a slow network, you can use:|
|    |                                                                                      |
|    |                                                                                      |
|    |shell> mysqladmin create nom_base_de_donnees                                          |
|    |shell> mysqldump -h 'other hostname' --opt --compress nom_base_de_donnees \           |
|    || mysql nom_base_de_donnees                                                           |
|    |You can also store the result in a file, then transfer the file to the target machine |
|    |and load the file into the database there. For example, you can dump a database to a  |
|    |file on the source machine like this:                                                 |
|    |                                                                                      |
|    |shell> mysqldump --quick nom_base_de_donnees | gzip > nom_base_de_donnees.contents.gz |
|    |(The file created in this example is compressed.) Transfer the file containing the    |
|    |database contents to the target machine and run these commands there:                 |
|    |                                                                                      |
|    |shell> mysqladmin create nom_base_de_donnees                                          |
|    |shell> gunzip < nom_base_de_donnees.contents.gz | mysql nom_base_de_donnees           |
|    |You can also use mysqldump and mysqlimport to accomplish the database transfer. For   |
|    |big tables, this is much faster than simply using mysqldump. In the commands shown    |
|    |below, DUMPDIR represents the full pathname of the directory you use to store the     |
|    |output from mysqldump.                                                                |
|    |First, create the directory for the output files and dump the database:               |
|    |                                                                                      |
|    |shell> mkdir DUMPDIR                                                                  |
|    |shell> mysqldump --tab=DUMPDIR nom_base_de_donnees                                    |
|    |Then transfer the files in the DUMPDIR directory to some corresponding directory on   |
|    |the target machine and load the files into MySQL there:                               |
|    |                                                                                      |
|    |shell> mysqladmin create nom_base_de_donnees           # create database              |
|    |shell> cat DUMPDIR/*.sql | mysql nom_base_de_donnees   # create tables in database    |
|    |shell> mysqlimport nom_base_de_donnees DUMPDIR/*.txt   # load data into tables        |
|    |Also, don't forget to copy the mysql database, since that's where the grant tables    |
|    |(user, db, host) are stored. You may have to run commands as the MySQL root user on   |
|    |the new machine until you have the mysql database in place.                           |
|    |After you import the mysql database on the new machine, execute mysqladmin            |
|    |flush-privileges so that the server reloads the grant table information.              |
|    |5 Compatibilité avec les standards                                                    |
|    |5.1 Extensions au langage ANSI SQL92                                                  |
|    |MySQL apporte quelques extensions à la norme ANSI SQL 92 que vous ne trouverez        |
|    |probablement dans aucune autre base de données. Soyez conscient que si vous utilisez  |
|    |ces extensions, votre code ne sera pas portable sur une autre base SQL. Dans certains |
|    |cas, vous pouvez écrire du code qui utilise ces extensions MySQL, mais qui est        |
|    |portable, en utilisant les commentaires de la forme /*! ... */. Dans ce cas, MySQL va |
|    |analyser puis exécuter le code de ce commentaire comme n'importe quelle commande      |
|    |MySQL, mais les autres serveur SQL les ignoreront. Par exemple :                      |
|    |                                                                                      |
|    |SELECT /*! STRAIGHT_JOIN */ nom_colonne FROM table1,table2 WHERE ...                  |
|    |Voici la liste des extensions MySQL:                                                  |
|    |Les types de colonnes MEDIUMINT, SET, ENUM et tous les types BLOB et TEXT.            |
|    |Les attributs de champs AUTO_INCREMENT, BINARY, UNSIGNED et ZEROFILL.                 |
|    |Toutes les comparaisons de chaînes sont insensibles à la casse par défaut, et le      |
|    |classement des chaînes est basé sur la table de caractère courante (par défaut,       |
|    |ISO-8859-1 Latin1). Si vous souhaitez que ces opérations soient sensible à la casse,  |
|    |ajoutez l'attribut BINARY aux colonnes concernés, ou bien utiliser l'opérateur de     |
|    |transptypage BINARY lors des comparaisons pour qu'elles prennent en compte l'ordre    |
|    |ASCII en cours sur l'hôte MySQL.                                                      |
|    |MySQL fait correspondre à chaque base de données un dossier dans le dossier de données|
|    |MySQL, et les tables de cette base seront représentées par des fichiers. Cela a deux  |
|    |conséquences :                                                                        |
|    |Les noms de bases de donnés et de tables sont dépendants du système d'exploitation sur|
|    |lequel MySQL tourne, notamment concertant la casse des noms. Si vous avez des         |
|    |difficultés à vous souvenir des noms de tables, utilisez une convention cohérente,    |
|    |comme par exemple celle de mettre tous les noms en minuscules.                        |
|    |Les noms de bases, de table, d'index, de colonne ou d' alias peuvent commencer par un |
|    |chiffre (mais de doivent pas être consistitués seulement de chiffres).                |
|    |Vous pouvez utiliser les commandes du système pour sauvegarder, renommer, déplacer,   |
|    |effacer et copier des tables. Par exemple, vous pouvez copier le ``.ISD'', ``.ISM'' et|
|    |``.frm'' pour créer une nouvelle table.                                               |
|    |En SQL pur, vous pouvez accéder à une table d'une autre base de données avec la       |
|    |syntaxe : nom_base_de_donnees.nom_table. Certains serveurs SQL propose la même        |
|    |fonctionnalité, mais l'appelle User space. MySQL n'accepte pas les espaces de tables  |
|    |comme dans : create table ralph.my_table...IN my_tablespace.                          |
|    |LIKE est utilisable avec les colonnes de type numérique                               |
|    |Possibilité d'utilisation de INTO OUTFILE et STRAIGHT_JOIN dans les commandes SELECT. |
|    |SELECT.                                                                               |
|    |L'option SQL_SMALL_RESULT dans une commande SELECT.                                   |
|    |EXPLAIN SELECT permet de voir de quelle manière les tables ont été regroupées.        |
|    |L'utilisation des index de noms, ou des index sur le préfixe d'un champs et           |
|    |l'utilisation de INDEX ou KEY dans une commande CREATE TABLE. CREATE TABLE            |
|    |Attribut TEMPORARY et IF NOT EXISTS dans la commande CREATE TABLE.                    |
|    |Utilisation de COUNT(DISTINCT liste) lorsque 'liste' contient plus d'un élément.      |
|    |Utilisation de CHANGE nom_colonne, DROP nom_colonne ou DROP INDEX dans les commandes  |
|    |ALTER TABLE. ALTER TABLE.                                                             |
|    |Utilisation de IGNORE dans les commandes ALTER TABLE.                                 |
|    |Utilisation de multiples ADD, ALTER, DROP ou CHANGE dans les commandes ALTER TABLE.   |
|    |Utilisation de DROP TABLE avec les mots clés IF EXISTS.                               |
|    |Vous pouvez supprimer plusieurs tables avec une seule commande DROP TABLE.            |
|    |Clause LIMIT dans les commandes DELETE.                                               |
|    |L'option DELAYED dans les commandes INSERT et REPLACE.                                |
|    |L'option LOW_PRIORITY dans les commandes INSERT, REPLACE, DELETE et UPDATE.           |
|    |Utilisation de LOAD DATA INFILE. Dans certains cas, cette syntaxe est compatibles avec|
|    |la fonction LOAD DATA INFILE d'Oracle. LOAD DATA.                                     |
|    |La commande OPTIMIZE TABLE. OPTIMIZE TABLE.                                           |
|    |La commande SHOW. SHOW.                                                               |
|    |Les chaînes de caractères peuvent être définies avec ``"'' ou ``''', et pas seulement |
|    |avec ``'''.                                                                           |
|    |Utilisation du caractère d'échappement ``\''.                                         |
|    |La commande SET OPTION. SET OPTION.                                                   |
|    |Vous n'avez pas à nommer expressément toutes les colonnes dans une clause GROUP BY.   |
|    |Mais cela peut permettre d'accélérer quelques requêtes très spécifiques. 7.3.13       |
|    |Fonctions à utiliser dans les clauses GROUP BY.                                       |
|    |Pour aider les utilisateurs d'autres environnements SQL, MySQL dispose d'aliases pour |
|    |de nombreuses fonctions. Par exemple, toutes les fonctions sur les chaînes de         |
|    |caractère supporte la syntaxe ANSI SQL et ODBC.                                       |
|    |MySQL accepte les opérateurs logiques || et && (OR et AND, comme en langage C). Sous  |
|    |MySQL, || et OR sont synonymes, tout comme le sont && et AND. A cause de ce double    |
|    |emploi, MySQL n'accepte pas les opérateurs ANSI SQL || comme additionneur de   |
|    |chaînes; (utilisez à la place CONCAT() ).. Etant donné que CONCAT() prend un nombre   |
|    |arbitraire d'arguments, il est facile de remplacer ||.                                |
|    |CREATE DATABASE ou DROP DATABASE. CREATE DATABASE                                     |
|    |L'opérateur % est synonyme de MOD(). C'est à dire que, N % M est équivalent à         |
|    |MOD(N,M). % est hérité du langage C, et permet la compatibilité avec PostgreSQL.      |
|    |Les opérateurs =, <>, <= ,<, >=,>, <<, >>, <=>, AND, OR ou LIKE peuvent être utilisés |
|    |dans les comparaisons de colonnes avec la clause FROM dans les commandes SELECT. Par  |
|    |exemple :                                                                             |
|    |                                                                                      |
|    |mysql> SELECT col1=1 AND col2=2 FROM nom_table;                                       |
|    |La fonction LAST_INSERT_ID(). mysql_insert_id.                                        |
|    |Les opérateurs d'expressions régulières REGEXP et NOT REGEXP.                         |
|    |CONCAT() ou CHAR() avec plus d'un one argument. (Avec MySQL, ces fonctions peuvent    |
|    |prendre un nombre arbitraire d'arguments).                                            |
|    |Les fonctions supplémentaires BIT_COUNT(), ELT(), FROM_DAYS(), FORMAT(), IF(),        |
|    |PASSWORD(), ENCRYPT(), md5(), ENCODE(), DECODE(), PERIOD_ADD(), PERIOD_DIFF(),        |
|    |TO_DAYS(), ou WEEKDAY().                                                              |
|    |Utilisation de TRIM() pour supprimer les espaces de début et fin de chaîne. ANSI SQL  |
|    |ne supporte que la suppression de caractères uniques.                                 |
|    |Les fonctions de GROUP BY : STD(), BIT_OR() et BIT_AND().                             |
|    |Utilisation de REPLACE à la place de DELETE + INSERT. REPLACE.                        |
|    |La commande FLUSH flush_option.                                                       |
|    |5.2 Différences entre MySQL et ANSI SQL92                                             |
|    |Nous t?chons de mettre MySQL aux normes ANSI SQL et ODBC SQL, mais dans certains cas, |
|    |MySQL gère les choses de manière différente.                                          |
|    |-- n'est pas un commentaire. 5.3.7 `--' comme début de commentaire.                   |
|    |Pour les colonnes de type VARCHAR, les espaces de fin de chaînes sont supprimés à     |
|    |l'enregistrement. Bugs.                                                               |
|    |Dans certains cas, les colonnes de type CHAR sont spontanément changées en colonne de |
|    |type VARCHAR. 7.6.1 Modifications automatiques de type de colonne.                    |
|    |Les droits d'une table ne sont pas supprimés lorsque vous supprimez une table. Vous   |
|    |devez explicitement appeler la commande REVOKE pour supprimer les droits de la table. |
|    |GRANT.                                                                                |
|    |5.3 Functionalités manquantes                                                         |
|    |Les fonctionnalités suivantes manquent dans la version courante de MySQL. La liste des|
|    |fonctionnalités classées par ordre de priorité est disponible en ligne à : F Liste de |
|    |voeux pour les versions futures de MySQL (la TODO).                                   |
|    |5.3.1 Sub-select                                                                      |
|    |La requête suivante ne fonctionne par encore sous MySQL:                              |
|    |                                                                                      |
|    |SELECT * FROM table1 WHERE id IN (SELECT id FROM table2);                             |
|    |SELECT * FROM table1 WHERE id NOT IN (SELECT id FROM table2);                         |
|    |Cependant, il est souvent possible de se passer d'une sous sélection :                |
|    |                                                                                      |
|    |SELECT table1.* FROM table1,table2 WHERE table1.id=table2.id;                         |
|    |SELECT table1.* FROM table1 LEFT JOIN table2 ON table1.id=table2.id where table2.id IS|
|    |NULL                                                                                  |
|    |Pour les sous requêtes compliquées, vous pouvez toujours créer une table temporaire,  |
|    |et y appliquer votre requête.                                                         |
|    |MySQL ne supporte que INSERT ... SELECT ... et REPLACE ... SELECT ... Les sous        |
|    |sélections indépendantes ne seront disponibles qu'à partir de la version 3.24.0.      |
|    |Actuellement, vous pouvez toujours utiliser la fonction IN() dans d'autres contextes. |
|    |5.3.2 SELECT INTO TABLE                                                               |
|    |MySQL ne supporte pas encore cette extension du SQL Orable.: SELECT ... INTO TABLE    |
|    |.... A la place, MySQL supporte la syntaxe de la norme ANSI SQL INSERT INTO ... SELECT|
|    |..., ce qui est pratiquement la même chose.                                           |
|    |Alternativement, vous pouvez utiliser SELECT INTO OUTFILE... ou CREATE TABLE ...      |
|    |SELECT pour résoudre votre problème.                                                  |
|    |5.3.3 Transactions                                                                    |
|    |Les transactions ne sont pas encore supportées par MySQL. Le serveur va bientôt       |
|    |accepter des opérations atomiques, ce qui permettra des transactions, mais sans le    |
|    |rollback. Avec les opérations atomiques, vous pourrez exécuter des groupes de         |
|    |commandes INSERT/SELECT/ avec n'importe quelle commande, et être sur qu'il n'y aura   |
|    |aucune interférence avec un autre thread. Dans ce contexte, vous n'aurez alors pas    |
|    |besoin de rollback. Actuellement, vous pouvez empêcher les autres threads d'interférer|
|    |en utilisant les fonctions LOCK TABLES et UNLOCK TABLES. LOCK TABLES.                 |
|    |5.3.4 Procédures stockées et triggers                                                 |
|    |Une fonctions enregistrée est un ensemble de commandes SQL qui peut être compilé et   |
|    |enregistré sur le serveur. Une fois fait, les clients peuvent se référer à cette      |
|    |fonction pour exécuter l'ensemble des commandes. Cela accélère le traitement des      |
|    |requêtes, car elles n'ont pas a être analysées, et moins d'information circule entre  |
|    |le client et le serveur. Il est aussi possible d'élever le niveau de conception, en   |
|    |b?tissant des bibliothèques.                                                          |
|    |Un trigger est une fonction enregistrée qui est invoquées à chaque fois qu'un         |
|    |événement particulier survient. Par exemple, vous pourriez installer une fonction qui |
|    |sera lancée à chaque fois qu'un enregistrement sera effacé dans une table de          |
|    |transaction, pour effacer automatiquement les informations correspondantes dans les   |
|    |tables de clients.                                                                    |
|    |Lors de modifications ultérieures, MySQL sera capable de gérer les fonctions          |
|    |enregistrées, mais pas les triggers. En général, les triggers ralentissent le serveur,|
|    |même pour des requêtes pour lesquelles ils ne sont pas appelés.                       |
|    |Pour savoir quand MySQL disposera des procédures enregistrées, sinon, F Liste de voeux|
|    |pour les versions futures de MySQL (la TODO).                                         |
|    |5.3.5 Clés étrangères                                                                 |
|    |Remarque : les clés externes en SQL ne sont pas utilisées pour effectuer des          |
|    |regroupements de table, mais pour assurer l'intégrité référentielle. Si vous voulez   |
|    |lire des informations depuis plusieurs tables avec une commande SELECT, c'est un      |
|    |regroupement !                                                                        |
|    |                                                                                      |
|    |SELECT * from table1,table2 where table1.id = table2.id;                              |
|    |JOIN. 8.3.5 Utiliser des clés étrangères                                              |
|    |La syntaxe FOREIGN KEY de MySQL n'existe que pour la compatibilité avec les commandes |
|    |CREATE TABLE des autres bases SQL : elle n'a aucun effet. La syntaxe FOREIGN KEY sans |
|    |la partie ON DELETE ... n'est utilisée que pour des raisons de documentation.         |
|    |Certaines applications ODBC l'utilise pour générer des clauses WHERE automatiques,    |
|    |mais il est généralement simple à remplacer. FOREIGN KEY est parfois utilisé comme    |
|    |contrainte, mais ce genre de vérification n'est pas nécessaire si les lignes ont été  |
|    |insérées dans l'ordre. MySQL ne supporte que ces clauses, car certaines applications  |
|    |en ont besoin (qu'elle fonctionne ou pas).                                            |
|    |Avec MySQL, vous pouvez contourner le problème sans la clause ON DELETE ... en        |
|    |ajoutant une commande DELETE adéquate lors de l'effacement d'un enregsitrement d'une  |
|    |table qui a une clé externe. En pratique, c'est aussi rapide (voire plus), et beaucoup|
|    |plus portable que les clés externes.                                                  |
|    |Dans un futur proche, nous allons implémenter FOREIGN KEY de manière à sauver les     |
|    |informations dans la table de spécification, pour qu'elles soient accessibles par     |
|    |mysqldump et ODBC.                                                                    |
|    |5.3.5.1 De bonnes raisons de ne pas utiliser les clés étrangères                      |
|    |Il y a tant de problèmes avec FOREIGN KEYs qu'on ne sait même pas par ou commencer :  |
|    |Les clés externes compliquent la vie, car les définitions des clés externes doivent   |
|    |être enregistrées dans une base de données, et les implémenter nous forcera à         |
|    |abandonner la gestion actuelle des tables (une table égale un fichier, qui peut être  |
|    |sauvé ou copié).                                                                      |
|    |L'impact sur la vitesse d'exécution de INSERT et UPDATE, et dans ce cas, presque      |
|    |toutes les vérifications dues à FOREIGN KEY ne servent à rien, car vous insérez les   |
|    |informations dans le bon ordre, naturellement.                                        |
|    |Les clés externes imposent l'utilisation de verrous sur de nombreuses tables, et cela |
|    |peut conduire, par effet de domino, à geler toute la base. Il est beaucoup plus rapide|
|    |d'effacer un enregistrement d'une table, puis de s'occuper des autres tables à la     |
|    |suite.                                                                                |
|    |Avec les clés externes, il n'est plus possible de reconstituer une table par un       |
|    |effacement complet, suivi d'un chargement de tous les enregistrements (depuis une     |
|    |nouvelle source, ou une sauvegarde).                                                  |
|    |Avec les clés externes, il est impossible faire un dump d'une table, puis de la       |
|    |recharger, à moins de le faire dans un ordre très spécifique.                         |
|    |Il est très facile de créer des références circulaires, qui sont autorisées, mais     |
|    |rendent impossible la recréation de la table à partir d'un enregistrement unique, même|
|    |si la définition de la table fonctionne et est utilisable.                            |
|    |Le seul aspect intéressant de FOREIGN KEY est de donner aux clients ODBC et quelques  |
|    |autres la possibilité de voir comment une table est connectée, et de l'utiliser pour  |
|    |créer un diagramme de connexion lors de la création d'applications.                   |
|    |MySQL gérera prochainement les définitions des FOREIGN KEY, ce qui permettra aux      |
|    |clients de réclamer la structure de la connexion originale. La version courantes des  |
|    |fichiers ``.frm'' ne le permet pas.                                                   |
|    |5.3.6 Vues                                                                            |
|    |MySQL ne supporte pas les vues, mais c'est sur la liste des fonctionnalités futures.  |
|    |5.3.7 `--' comme début de commentaire                                                 |
|    |Sur d'autres bases SQL les commentaires commencent par ``--''. MySQL utilise ``#''    |
|    |pour débuter un commentaire, même si mysql supprime aussi les lignes qui commencent   |
|    |par ``--''. Vous pouvez aussi utiliser le style de commentaires C /* Ceci est un      |
|    |commentaire */ avec MySQL. Comments.                                                  |
|    |MySQL n'accepte pas les commentaires commencant par ``--''; car ce style de           |
|    |commentaire obsolète a déjà causé de nombreux problèmes avec les requêtes générées    |
|    |automatiquement, lorsque la base utilise un code comme celui ci : la valeur de        |
|    |paiement va être placée à la place de !paiement!:                                     |
|    |                                                                                      |
|    |UPDATE nom_table SET credit=credit-!paiement!                                         |
|    |Mais que ce passe t il si la valeur de paiement est négative?                         |
|    |Etant donné que 1--1 valide en SQL, nous pensons que les commentaires commencé par    |
|    |``--'' sont une très mauvaise idée.                                                   |
|    |Si vous avez un programme SQL qui contient des commentaires avec le format ``--'' vous|
|    |devriez utiliser:                                                                     |
|    |                                                                                      |
|    |shell> replace " --" " #" < Fichier-texte-avec-des-commentaires-zarbi | mysql database|
|    |A la place de l'habituel :                                                            |
|    |                                                                                      |
|    |shell> mysql database < text-file-with-funny-comments.sql                             |
|    |Vous pouvez aussi utiliser la commande fichier ``in place'' pour remplacer les        |
|    |commentaires ``--'' par ``#'':                                                        |
|    |                                                                                      |
|    |shell> replace " --" " #" -- text-file-with-funny-comments.sql                        |
|    |Retrouvez vos situation initiale avec :                                               |
|    |                                                                                      |
|    |shell> replace " #" " --" -- text-file-with-funny-comments.sql                        |
|    |5.4 Quels sont les standards que respecte MySQL?                                      |
|    |SQL92. ODBC level 0-2.                                                                |
|    |5.5 Comment se débrouiller sans COMMIT/ROLLBACK                                       |
|    |MySQL ne supporte pas COMMIT-ROLLBACK. Le problème tient à ce que COMMIT-ROLLBACK     |
|    |requiert une structure de table completement différente ce celle qui est utilisée     |
|    |actuellement. MySQL aurait besoin d'autres threads pour nettoyer automatiquement les  |
|    |tables et l'utilisation du disque serait augmentée d'autant. Ce qui ralentirait MySQL |
|    |d'un facteur de 2 à 4. MySQL est beaucoup plus rapide que bien d'autres bases SQL (en |
|    |général, de 2 à 3 fois plus rapide.). Une des raisons de cette vélocité est l'absence |
|    |de COMMIT-ROLLBACK.                                                                   |
|    |Pour le moment, nous sont concentrés sur l'implémentation du langage de serveur SQL   |
|    |(comme par exemple, les fonctions enregistrées). Avec ces fonctions, vous ne devriez  |
|    |faire appel au COMMIT-ROLLBACK que de manière exceptionnelle.                         |
|    |Les boucles que nécessite les transactions peuvent être remplacées avantageusement par|
|    |les LOCK TABLES, et vous n'aurez pas besoin de curseurs si vous pouvez modifier des   |
|    |enregistrements à la volée.                                                           |
|    |Les transactions et les curseurs sont sur la liste de voeux, mais elles ne sont pas   |
|    |prioritaires. Si nous les implémentons, ce sera sous la forme d'une option de CREATE  |
|    |TABLE. Cela signifie que COMMIT-ROLLBACK ne fonctionnera qu'avec ces tables, ce qui ne|
|    |pénalisera que les tables qui auront cette option, et non plus la base toute entière. |
|    |Ici, à TcX, nous avons un plus grand besoin d'une base de données rapide que d'une    |
|    |base de données généraliste. Si nous trouvons un moyen d'ajouter ces fonctionnalités  |
|    |sans perte de vitesse, nous le ferons sûrement. Pour le moment, nous avons d'autres   |
|    |choses plus importantes. Reportez tous à la liste des voeux pour savoir quelles sont  |
|    |les priorités (les clients de haut niveau de support peuvent cependant faire bouger   |
|    |les choses).                                                                          |
|    |Le problème actuel est au niveau de ROLLBACK. Sans le ROLLBACK, vous pouvez effectuer |
|    |des commandes de type COMMIT en utilisant la commande LOCK TABLES. Pour permettre le  |
|    |support du ROLLBACK, MySQL devra enregistrer tous les vieux enregistrements qui sont  |
|    |modifiés ou effacé, pour pouvoir les restituer si un ROLLBACK intervient. Pour les cas|
|    |simples, ce n'est pas compliqué à mettre en place (l'utilitaire actuel isamlog peut   |
|    |servir à ce propos), mais cela peut se révéler plus compliqué pour les commandes      |
|    |ALTER/DROP/CREATE TABLE.                                                              |
|    |Pour éviter d'utiliser le ROLLBACK, vous pouvez suivre la stratégie suivante :        |
|    |Utilisez LOCK TABLES ... pour verrouiller les tables auxquelles vous accédez          |
|    |Testez les conditions d'utilisation.                                                  |
|    |Modifiez si tout est OK.                                                              |
|    |Utilisez UNLOCK TABLES pour libérer la table.                                         |
|    |Généralement, cette méthode est beaucoup plus rapide que les transactions, et le      |
|    |ROLLBACK est souvent possible, mais pas toujours. Le seul point critique est que si le|
|    |threads est tué au milieu de la modification, les verrous seront libérés, mais une    |
|    |partie des modifications ne sera pas faites.                                          |
|    |Vous pouvez aussi utiliser les fonctions qui modifient un seul enregistrement à la    |
|    |fois. Vous pouvez créer des applications très efficaces avec la technique suivante :  |
|    |Modifier un champs par rapport à sa valeur actuelle                                   |
|    |Modifier seulement les champs qui ont changés                                         |
|    |Par exemple, lors vous modifiez les informations concernant un client, ne modifiez que|
|    |les informations qui ont changées, et non pas celle qui sont restées constantes. La   |
|    |recherche des valeurs est faites avec la clause WHERE de la commande UPDATE. Si       |
|    |l'enregistrement a changé, on peut retourner au client une message du type : "Les     |
|    |informations n'ont pas été modifiées, car un autre utilisateur est en train de        |
|    |modifier les valeurs ". Alors, on affiche l'ancienne valeur et la nouvelle, ce qui    |
|    |permet à l'utilisateur de décider quelle version utiliser.                            |
|    |Cela fournit un mécanisme du genre ``verrouillage de colonne'' mais c'est en fait un  |
|    |peut mieux, car seule les colonnes qui en on besoin sont utilisées. Une commande      |
|    |UPDATE ressemblera alors à ceci :                                                     |
|    |                                                                                      |
|    |UPDATE tablename SET pay_back=pay_back+'différence de valeur';                        |
|    |UPDATE customer                                                                       |
|    |SET                                                                                   |
|    |customer_date='date actuellee',                                                       |
|    |address='nouvelle adresse',                                                           |
|    |phone='nouveau numero de telephone',                                                  |
|    |débit =débit + 'autre_débit'                                                          |
|    |WHERE                                                                                 |
|    |customer_id=id AND address='vieille addresse' AND phone='vieux numero de telephone';  |
|    |Comme vous pouvez le voir, c'est une méthode très efficace, et qui fonctionne même si |
|    |un autre client a changé la valeur entre temps.                                       |
|    |Dans certains cas, l'utilisateur ont demandé le ROLLBACK et/ou LOCK TABLES dans le but|
|    |de gérer des identifiants uniques dans des tables . Il vaut mieux utiliser le type de |
|    |colonne AUTO_INCREMENT et la fonction SQL LAST_INSERT_ID() ou l' API C :              |
|    |mysql_insert_id(). mysql_insert_id().                                                 |
|    |A TcX, nous n'avons jamais eu besoin d'un verrouillage de ligne, car nous avons       |
|    |toujours réussit à contourner le problème. Dans certains cas, le verrouillage de ligne|
|    |était nécessaire, mais c'est très rarement le cas. Si vous voulez le verrouillage de  |
|    |ligne, utiliser un flag sur une colonne dans la table comme ci :                      |
|    |                                                                                      |
|    |UPDATE nom_table SET row_flag=1 WHERE id=ID;                                          |
|    |MySQL retourne 1, ce qui correspond au nombre de ligne affectées par la commande, si  |
|    |la ligne a été trouvée, et que le flag row_flag n'était pas déjà à 1.                 |
|    |Vous pouvez considérer que MySQL traite la requête ci dessus de la manière suivante : |
|    |                                                                                      |
|    |UPDATE nom_table SET row_flag=1 WHERE id=ID and row_flag <> 1;                        |
|    |6 Systèmes de droits MySQL                                                            |
|    |MySQL dispose d'un système moderne mais original de droits d'accès. Cette section le  |
|    |décrit.                                                                               |
|    |6.1 A quoi sert le système de droits                                                  |
|    |La fonction primaire du système de droits de MySQL est d'authentifier un utilisateur  |
|    |se connectant, et l'associer avec les droits d'utilisation des commandes select,      |
|    |insert, update et delete sur cette base.                                              |
|    |Les fonctions secondaires inclus la possibilité d'accueillir un utilisateur anonyme,  |
|    |et de donner des droits particuliers à des fonctions spécifiques à MySQL LOAD DATA    |
|    |INFILE et les opérations.                                                             |
|    |6.2 Noms et mot de passe des d'utilisateurs MySQL                                     |
|    |Il y a de grandes différences entre la gestion des noms d'utilisateur et mots de passe|
|    |de MySQL, et celle de Unix ou de Windows.                                             |
|    |Les noms d'utilisateurs, utilisé par MySQL pour l'authentification, n'ont rien à voir |
|    |avec les nom d'utilisateur de Unix (Nom de login) ou de Windows. La plus part des     |
|    |clients MySQL essaie de se connecter à la base avec le nom d'utilisateur Unix courant,|
|    |mais cela est uniquement par commodité. Les programmes clients permettent de se       |
|    |connecter sous un autre nom, spécifié avec l'option -u ou --user. Cela signifie que   |
|    |vous ne pouvez sécuriser un serveur MySQL qu'en ayant un mot de passe pour chacun des |
|    |utilisateurs. Sinon, n'importe quelle personne qui se connecte en utilisant n'importe |
|    |quel nom, réussira à se connecter, si ce nom d'utilisateur n'a pas de mot de passe.   |
|    |Les noms d'utilisateurs MySQL peuvent avoir jusqu'à 16 caractères de long.            |
|    |Généralement, les noms d'utilisateur Unix sont limités à 8 caractères.                |
|    |Les mots de passe MySQL n'ont rien à voir non plus avec le mot de passe Unix ou       |
|    |Windows. Il n'y a pas de connexion entre les deux, mais ils peuvent être identiques.  |
|    |Les mots de passe MySQL sont cryptés avec un cryptage différents de celui d'Unix.     |
|    |Reportez vous à la description de la commande PASSWORD()et ENCRYPT() dans la section  |
|    |7.3.12 Fonctions diverses.                                                            |
|    |6.3 Connection au serveur MySQL                                                       |
|    |Les clients MySQL ont besoin d'un certains nombre de paramètres pour se connecter à un|
|    |serveur MySQL : l'hôte qui abrite le serveur, le nom d'utilisateur et le mot de passe.|
|    |Par exemple, le client mysql peut être lancé avec la ligne suivante : (les arguments  |
|    |optionnels sont mis entre crochets ``['' et ``]''):                                   |
|    |                                                                                      |
|    |shell> mysql [-h host_name] [-u user_name] [-pyour_pass]                              |
|    |Il est aussi possible de remplacer respectivement les options -h, -u et -p            |
|    |par--host=host_name, --user=user_name et --password=your_pass. Notez bien qu'il n'y as|
|    |pas d'espace entre -p ou --password= et le mot de passe qui le suit.                  |
|    |Note: Transmettre un mot de passe dans la ligne de commande n'est pas sécurisé !      |
|    |N'importe quel utilisateur du système peut découvrir le mot de passe en tapant : ps   |
|    |auxww. 4.15.4 Fichier d'options.                                                      |
|    |Par défaut, mysql utilise les valeurs suivantes :                                     |
|    |Le nom d'hôte par défaut est localhost, c'est à dire la machine locale.               |
|    |Le nom d'utilisateur par défaut est le nom de login Unix.                             |
|    |Aucun mot de passe n'est envoyé si -p n'est pas précisé.                              |
|    |Ainsi, pour un utilisateur Unix joe, les commandes suivantes sont équivalentes :      |
|    |                                                                                      |
|    |shell> mysql -h localhost -u joe                                                      |
|    |shell> mysql -h localhost                                                             |
|    |shell> mysql -u joe                                                                   |
|    |shell> mysql                                                                          |
|    |D'autres clients MySQL se comportent de manière similaire :                           |
|    |Sous Unix, vous pouvez spécifier d'autres valeurs par défaut, lors de la connexion, ce|
|    |qui vous évitera d'entrer les paramètres à chaque connexion. Cela peut être fait de   |
|    |diverses façons :                                                                     |
|    |Vous pouvez spécifier les paramètres de connexion dans la section [client] du fichier |
|    |de configuration ``.my.cnf'' de votre dossier personnel. Les informations doivent être|
|    |présentées comme suit :                                                               |
|    |                                                                                      |
|    |[client]                                                                              |
|    |host=host_name                                                                        |
|    |user=user_name                                                                        |
|    |password=your_pass                                                                    |
|    |4.15.4 Fichier d'options                                                              |
|    |Vous pouvez spécifier les paramètres de connexion en utilisant les variables          |
|    |d'environnement. L'hôte sera spécifié avec la variable MYSQL_HOST. Le nom             |
|    |d'utilisateur MySQL peut être spécifié avec les variables USER, LOGNAME ou LOGIN (bien|
|    |que ces variables peuvent avoir déjà été réservé pour votre login de connexion, et ce |
|    |ne serait pas conseillé de les changer). Le mot de passe sera spécifié dans la        |
|    |variable MYSQL_PWD ( mais ce n'est pas très sur, comme vous le verrez à la prochaine  |
|    |section).                                                                             |
|    |Si les paramètres de connexion sont spécifiables de nombreuses manières, les valeurs  |
|    |spécifiées sur la ligne de commande ont priorité sur les valeurs enregistrées dans le |
|    |fichier de configuration, et ces dernières ont priorité sur les variables             |
|    |d'environnement.                                                                      |
|    |•  6.4 Un mot de passe sûr                                                            |
|    |Il n'est pas conseillé d'exposer son mot de passe, ou de le stocker dans des endroits |
|    |qui faciliterait sa connaissances par d'autres utilisateurs. Les méthodes de          |
|    |spécifications du mot de passe lors du lancement du programme client sont présentées  |
|    |ci-dessous, avec à chaque fois, les risques de la méthode :                           |
|    |Utiliser la ligne de commande avec l'option -pyour_pass ou --password=your_pass. C'est|
|    |très pratique, mais très dangereux, ca le mot de passe devient visible pour les       |
|    |commandes de statut du système (comme par exemple ps) qui peut être invoqué pas       |
|    |d'autres utilisateurs. Les clients MySQL remplace le mot de passe par une ligne de    |
|    |zéro lors de la séquence d'initialisation, mais il y a quand même un temps très bref, |
|    |où la valeur est écrite en clair).                                                    |
|    |Utiliser la ligne de commande avec l'option -p ou --password (sans valeur spécifiée). |
|    |Dans ce cas, le programme client va solliciter le mot de passe depuis la console :    |
|    |                                                                                      |
|    |shell> mysql -u user_name -p                                                          |
|    |Enter password: ********                                                              |
|    |Le client renvoie les caractères``*'' à la console, au fur et à mesure que vous entrez|
|    |votre mot de passe, ce qui fait que quelqu'un derrière votre épaule ne pourra pas le  |
|    |voir. La sécurité est donc renforcée par rapport à la méthode précédente, mais cela   |
|    |oblige à utiliser le client en mode interactif. Vous ne pourrez pas lancer le         |
|    |programme depuis un script.                                                           |
|    |Enregistrez votre mot de passe dans un fichier de configuration. Par exemple, vous    |
|    |pouvez mettre votre mot de passe dans la section [client] du fichier de configuration |
|    |``.my.cnf'' de votre dossier home.                                                    |
|    |                                                                                      |
|    |[client]                                                                              |
|    |password=your_pass                                                                    |
|    |Si vous stockez votre mot de passe dans le fichier ``.my.cnf'', ce fichier ne doit pas|
|    |être accessible en lecture ou en écriture ni au groupe, ni au monde. Assurez vous que |
|    |le mode d'accès du fichier est 400 ou 600. 4.15.4 Fichier d'options.                  |
|    |Vous pouvez enregistrer votre mot de passe dans la variable d'environnement MYSQL_PWD,|
|    |mais cette méthode doit être considéré comme extrêmement dangereuse. Certaines options|
|    |de ps permettent d'avoir accès aux variables d'environnement des processus en cours,  |
|    |ce qui fait que votre mot de passe peut être parfaitement lisible. Même sur des       |
|    |systèmes qui n'ont pas cette version de ps, il est fortement déconseillé de supposer  |
|    |qu'il n'y a pas d'autres méthode d'observation des processus.                         |
|    |L'un dans l'autre, la méthode la plus sûre est de fournir le mot de passe à la        |
|    |console, ou de spécifier le mot de passe dans le fichier ``.my.cnf'', correctement    |
|    |protégé.                                                                              |
|    |6.5 Droits sous MySQL                                                                 |
|    |Les droits sont conservés dans les tables user, db, host, tables_priv et columns_priv |
|    |de la base de données. Le serveur MySQL lis le contenu de ces tables au démarrage, et |
|    |à chaque fois que c'est nécessaire, comme décrit dans la section 6.9 Prise en compte  |
|    |des modifications de droits.                                                          |
|    |Les noms utilisés dans ce manuel pour se référer aux droits de MySQL sont listés      |
|    |ci-dessous, avec le nom de la colonne associé à chaque droit dans la table de droits, |
|    |et le contexte d'application du droit.                                                |
|    |Les droits select, insert, update et delete permettent d'exécuter des opérations sur  |
|    |les lignes dans les tables existantes d'une base. Vous pouvez même exécuter certaines |
|    |commandes SELECT sans avoir accès à aucune base sur le serveur. Par exemple, vous     |
|    |pouvez utiliser mysql comme une simple calculatrice :                                 |
|    |                                                                                      |
|    |mysql> SELECT 1+1;                                                                    |
|    |mysql> SELECT PI()*2;                                                                 |
|    |Le droit index vous permet de créer ou de détruire des index.                         |
|    |Le droit alter vous permet d'utiliser la commande ALTER TABLE.                        |
|    |Les droits create et drop vous permet de créer et détruire de nouvelles tables et     |
|    |bases.                                                                                |
|    |Il faut bien remarquer que si vous donnez le droit de drop pour la base mysql , un    |
|    |utilisateur pourra effacer la table des droits MySQL!                                 |
|    |Le droit grant vous permet de donner des droits que vous possédez à un autre          |
|    |utilisateur.                                                                          |
|    |Le droit file vous permet de lire et écrire des fichiers sur le serveur, en utilisant |
|    |les commandes LOAD DATA INFILE et SELECT ... INTO OUTFILE. Tout utilisateur qui       |
|    |dispose de ce droit peut écrire ou lire des fichiers que MySQL peut écrire ou lire.   |
|    |Les autres droits sont utilisés pour les opérations administratives, qui sont         |
|    |disponibles avec mysqladmin. La table ci-dessous montre quelle droit donne accès à    |
|    |quelle commande mysqladmi:                                                            |
|    |La commande reload force le serveur à relire les tables de droits. La commande refresh|
|    |vide toutes les tables de la mémoire, et ouvre puis ferme les fichiers d'historique.  |
|    |flush-privileges est un synonyme de reload. Les autres commandes flush-* exécutent des|
|    |fonctions similaires à refresh mais ne sont pas aussi limitées, et parfois même, elles|
|    |sont préférables. Par exemple, si vous souhaitez uniquement enregistrer les fichiers  |
|    |d'historique, flush-logs est mieux que refresh.                                       |
|    |La commande shutdown éteint le serveur.                                               |
|    |La commande processlist affiche la liste des threads courant du serveur. La commande  |
|    |kill arrête les threads du serveur. Vous pouvez toujours afficher et détruire les     |
|    |threads que vous possédez, mais vous devez avoir les droits de process pour afficher  |
|    |ou terminer les threads d'un autre utilisateur.                                       |
|    |La meilleure stratégie est de ne donner des droits qu'à ceux qui en ont besoin, mais  |
|    |il faut être particulièrement prudents avec certains droits :                         |
|    |Le droit de grant permet à utilisateur de donner ses propres droits à un autre. Deux  |
|    |utilisateurs pourront alors s'échanger les droits, et ainsi, obtenir des droits       |
|    |supplémentaires.                                                                      |
|    |Les droits de alter peuvent être utilisés pour renommer des tables systèmes           |
|    |Les droits de file peuvent être détourné : en lisant n'importe quel fichier (sensible |
|    |de préférence) sur le serveur pour le monter dans une base de données, il est alors   |
|    |possible d'accéder au contenu en utilisant la commande SELECT.                        |
|    |Les droits de shutdown peuvent être utilisé pour empêcher l'accès au serveur, en      |
|    |l'éteignant.                                                                          |
|    |Les droits de process permettent à un utilisateur de voir les commandes des autres    |
|    |utilisateurs, sans cryptage, notamment les commandes de changement de mot de passe.   |
|    |Les droits sur la base mysql peuvent être utilisés pour changer des mots de passe, ou |
|    |tout autre droit d'accès. (Les mots de passes sont cryptés avant d'être enregistrés,  |
|    |ce qui empêche leur relecture. Mais avec les droits adéquats, un utilisateur peu      |
|    |scrupuleux peu les remplacer par d'autre mot de passe, et empêcher l'accès).          |
|    |Il y a des limitations avec les droits MySQL:                                         |
|    |Vous ne pouvez pas refuser des droits à un utilisateur. Vous ne pouvez pas spécifier  |
|    |un utilisateur, et lui refuser spécialement les droits de connexion.                  |
|    |Vous ne pouvez pas séparer les droits de création et d'effacement des tables et de la |
|    |bases de données qui les contient. L'utilisateur pourra créer et effacer les tables ET|
|    |la base.                                                                              |
|    |6.6 Fonctionnement du système de droits                                               |
|    |MySQL s'assure que tous les utilisateurs peuvent faire ce qu'ils ont le droit de      |
|    |faire. Lorsque vous vous connectez à un serveur MySQL, le serveur détermine votre     |
|    |identité gr?ce à l'hôte depuis lequel vous vous connectez, et le nom d'utilisateur que|
|    |vous spécifiez.. Le système vous alloue alors les droits adéquats.                    |
|    |MySQL considère que le nom de l'hôte et le nom d'utilisateur sont suffisants pour vous|
|    |identifier sans ambiguïté, car il y a peu de chance qu'un nom d'utilisateur soit      |
|    |utilisé par la même personne, depuis tous les hôtes sur Internet ! Par exemple,       |
|    |l'utilisateur bill qui se connecte depuis whitehouse.gov ne sera probablement pas la  |
|    |même personne que l'utilisateur bill qui se connecte depuis microsoft.com. MySQL vous |
|    |permet de distinguer les deux utilisateurs, et de donner des droits différents pour le|
|    |même nom d'utilisateur, mais pour des hôtes différents.                               |
|    |MySQL contrôle l'accès en deux temps :                                                |
|    |Etape 1: le serveur vérifie que vous êtes autorisés à vous connecter.                 |
|    |Etape 2: Si vous pouvez vous connecter, le serveur vérifie chaque requête que vous    |
|    |émettez pour voir sir vous avez des droits suffisants. Par exemple, pour sélectionner |
|    |des lignes dans une table, ou effacer une table dans une base, le serveur s'assure que|
|    |vous avez les droits de select ou de drop pour la base de données courante.           |
|    |Le serveur utilise les tables user, db et host de la base mysql pour conserver les    |
|    |informations de connexion et les droits. Les champs de ces tables sont les suivants : |
|    |Pour la deuxième étape d'accès, le serveur peut consulter éventuellement (si la       |
|    |requête implique des tables)les tables tables_priv et columns_priv. Les champs de ces |
|    |tables sont les suivants :                                                            |
|    |Chaque table de droits contient les champs d'identification et de droits.             |
|    |Les champs d'identification détermine le contexte d'application des droits. Par       |
|    |exemple, la table user avec une ligne dont les champs Host, User ont les valeurs de   |
|    |'thomas.loc.gov' et 'bob' seront utilisés pour identifier les connexions de bob depuis|
|    |thomas.loc.gov. De la même façon, la table db avec une ligne dont les champs Host,    |
|    |User et Db sont respectivement 'thomas.loc.gov', 'bob' et 'reports' seront utilisés   |
|    |lors que bob se connecte depuis host thomas.loc.gov pour accéder à la base reports.   |
|    |Les tables tables_priv et columns_priv contiennent les noms des tables et des tables /|
|    |colonnes pour qui s'appliquent les droits.                                            |
|    |Pour des raisons de vérifications d'accès, les comparaisons effectuées sur les        |
|    |colonnes Host sont insensibles à la casse.. User, Password, Db et Table_name sont     |
|    |sensibles à la casse.. Column_name est insensible à la casse depuis MySQL 3.22.12.    |
|    |Les champs de droits indiques quels droits sont donnés, quelles commandes sont        |
|    |autorisées. Le serveur combine les informations des différentes tables pour construire|
|    |une fiche complète de description des droits du serveur. Les règles utilisées pour    |
|    |cela sont décrites dans la section 6.8 Contrôle d'accès, étape 2 : vérification des   |
|    |requêtes.                                                                             |
|    |Les champs d'identification sont des chaînes, déclarées comme ci-dessous. La valeur   |
|    |par défaut de chaque champs est la chaîne vide.                                       |
|    |Dans les tables user, db et host, tous les champs de droits sont déclarés comme des   |
|    |ENUM('N','Y') - chaque champs peut prendre la valeur 'N' ou 'Y', et la valeur par     |
|    |défaut est 'N'.                                                                       |
|    |Dans les tables tables_priv et columns_priv, Les champs de droits sont déclarés comme |
|    |des SET:                                                                              |
|    |Présenté rapidement, le serveur utilises les tables de droits comme ceci :            |
|    |La table user détermine le droit de connexion. Pour les connexions autorisées, les    |
|    |droits globaux de l'utilisateurs sont précisés.                                       |
|    |Les tables db et host sont utilisées ensembles :                                      |
|    |La table db détermine quelles bases sont accessibles à quels utilisateurs. Les champs |
|    |de droits déterminent quels sont les droits autorisés.                                |
|    |La table host est utilisée comme une extension de db lorsque vous voulez qu'une ligne |
|    |de db s'applique à plusieurs hôtes. Par exemple, si vous voulez qu'un utilisateur soit|
|    |capable d'accéder à la base depuis plusieurs hôtes différents, laissez le champs Host |
|    |de la table db vide, puis ajoutez un enregistrement dans la table host pour chaque    |
|    |hôte à autoriser. Ce mécanisme est décrit en détails dans la section 6.8 Contrôle     |
|    |d'accès, étape 2 : vérification des requêtes.                                         |
|    |Les tables tables_priv et columns_priv sont similaires à la table db, mais            |
|    |s'appliquent au niveau table et colonne, plutôt qu'au niveau base.                    |
|    |Notez bien que les droits administratifs (tels reload, shutdown, etc.) ne sont        |
|    |spécifiés que dans la tables user. En effet, les opérations administratives sont des  |
|    |opérations sur le serveur lui-même, et ne sont pas spécifiques à une base de données :|
|    |il n'y a pas de raison d'avoir ces privilèges dans d'autres tables. En fait, seule la |
|    |table user est consultée pour déterminer les droits administratifs.                   |
|    |Le droit file est spécifié seulement dans la table user. Ce n'est pas un droit        |
|    |administratif, mais il n'est pas dépendant de la table, ou de la base en cours.       |
|    |Le serveur mysqld lit le contenu des tables de droits au démarrage. Les modifications |
|    |des tables de droits ne prennent effets qu'à des moments précis, comme précisé dans la|
|    |6.9 Prise en compte des modifications de droits.                                      |
|    |Lorsque vous modifiez le contenu des tables de droits, il es important de s'assurer   |
|    |que les modifications de droits produiront bien l'effet désiré. Il existe une aide    |
|    |pour comprendre ces erreurs, reportez vous à la section Security.                     |
|    |Un outil d'analyse pratique est le script mysqlaccess, qui est fournit gracieusement  |
|    |par Yves Carlier dans la distribution de MySQL. Lancez mysqlaccess avec l'option      |
|    |--help pour comprendre comment il fonctionne. Notez que mysqlaccess utilise les droits|
|    |des tables user, db et host. Il ne prend pas en compte les droits sur les tables ou   |
|    |les colonnes.                                                                         |
|    |6.7 Contrôle d'accès, étape 1 : vérification de la connexion                          |
|    |Lorsque vous tentez de vous connecte à un serveur MySQL, le serveur accepte ou rejete |
|    |votre tentative en fonction de votre identité, et de votre capacité à fournir le mot  |
|    |de passe correct. Dans le cas contraire, le serveur refuse complètement l'accès.      |
|    |Sinon, le serveur accepte la connexion, et passe en niveau 2, pour attendre les       |
|    |requêtes.                                                                             |
|    |L'identité lors de la connexion est basé sur deux éléments :                          |
|    |L'hôte depuis lequel vous vous connectez                                              |
|    |Votre nom d'utilisateur MySQL                                                         |
|    |La vérification de l'identité est faite en utilisant les trois champs d'identité de la|
|    |table user (Host, User et Password). Le serveur n'acceptera une connexion que si il   |
|    |existe un enregistrement qui contienne votre hôte, votre nom d'utilisateur et votre   |
|    |mot de passe.                                                                         |
|    |Les valeurs de la table user peuvent être fournies avec les propriétés suivante :     |
|    |Host peut être un nom d'hôte, ou une adresse IP ou 'localhost' pour indiquer la       |
|    |machine locale.                                                                       |
|    |Vous pouvez utilisez les caractères spéciaux ``%'' et ``_'' dans le champs Host.      |
|    |Host qui vaut '%' accepte tous les hôtes. Host vide est équivalent à to '%'. Notez que|
|    |ces valeurs accepte n'importe quel hôte qui peut créer une connexion avec votre       |
|    |serveur !                                                                             |
|    |Les caractères spéciaux ne sont pas autorisés dans le champs User, mais vous pouvez le|
|    |laisser vide, ce qui équivaudra à '%'. Si un enregistrement de la table user a un     |
|    |champs User vide, cet utilisateur sera considéré comme anonyme (utilisateur sans nom) |
|    |plutôt qu'étant l'utilisateur avec le nom spécifié par le client. Cela signifie que   |
|    |l'utilisateur vide sera utilisé ultérieurement pour toutes les vérifications de       |
|    |droits, durant toute la connexion.                                                    |
|    |Le champs Password peut être laissé vide. Cela ne signifie pas que n'importe quel mot |
|    |de passe sera accepté, mais que l'utilisateur doit se connecter SANS mot de passe.    |
|    |Les valeurs de Password qui ne sont pas vides représentent des mots de passe cryptés. |
|    |MySQL ne conserve pas les mots de passe en clair, qui risqueraient ainsi d'être vu par|
|    |n'importe qui. Lors de la connexion, le mot de passe fourni est crypté de la même     |
|    |manière que le mot de passe enregistré, et les deux valeurs sont comparées. Si les    |
|    |deux correspondent, le mot de passe fourni est le bon.                                |
|    |Les exemples suivants montrent différentes combinaisons des colonnes Host et User de  |
|    |la table user :                                                                       |
|    |Etant donné que l'on peut utiliser des jokers dans le champs Host (i.e.,              |
|    |'144.155.166.%' pour accepter tout un sous domaine), il est possible que quelqu'un    |
|    |essaie d'exploiter ceci en prenant comme nom 144.155.166.petaouschnock.com. Pour      |
|    |contrer ce genre de tentatives, MySQL n'accepte pas les noms d'hôtes qui commencent   |
|    |par des chiffres suivis d'un point. Ainsi, un hote du genre 1.2.foo.com ne pourra     |
|    |jamais être accepté. Seule les IP numériques peuvent utiliser un joker.               |
|    |Une connexion entrante peut disposer de plusieurs entrées dans la table user. Par     |
|    |exemple, la connexion thomas.loc.gov de fred pouurait être acceptée plusieurs fois    |
|    |dans les exemples ci-dessus. Comment le serveur fait il pour choisir une entrée ou une|
|    |autre ? Il résoud la question en triant les utilisateurs au moment du démarrage, et en|
|    |lisant les entrées dans cet ordre trié. La première ligne qu'il trouve est alors la   |
|    |bonne.                                                                                |
|    |La table user fonctionne comme ceci. Supposons qu'elle ressemble à ceci :             |
|    |                                                                                      |
|    |+-----------+----------+-                                                             |
|    || Host      | User     | ...                                                          |
|    |+-----------+----------+-                                                             |
|    || %         | root     | ...                                                          |
|    || %         | jeffrey  | ...                                                          |
|    || localhost | root     | ...                                                          |
|    || localhost |          | ...                                                          |
|    |+-----------+----------+-                                                             |
|    |Lorsque le serveur lit la table, il classe les lignes en commencant par les hôtes les |
|    |moins généraux ('%' dans la colonne Host signifie ``tous les hôtes'' et c'est le cas  |
|    |le plus général). Les lignes avec le même hôte sont classé en commencant par les      |
|    |utilisateurs les moins généraux (un utilisateur en blanc signifie ``tous les          |
|    |utilisateurs'' et c'est le cas le plus général. Une fois triée, la table ressemble à  |
|    |ceci :                                                                                |
|    |                                                                                      |
|    |+-----------+----------+-                                                             |
|    || Host      | User     | ...                                                          |
|    |+-----------+----------+-                                                             |
|    || localhost | root     | ...                                                          |
|    || localhost |          | ...                                                          |
|    || %         | jeffrey  | ...                                                          |
|    || %         | root     | ...                                                          |
|    |+-----------+----------+-                                                             |
|    |Lors d'une connexion, le serveur recherche parmi les lignes classées, et utilise la   |
|    |première ligne qui aille et l'utilise. Si la connexion entrante vient de l'hôte       |
|    |localhost et de l'utilisateur jeffrey, les premières lignes, avec 'localhost' sont    |
|    |trouvées. Parmi celles-ci, la ligne avec le champs utilisateur vide correspond à la   |
|    |connexion. (la linge avec '%'/'jeffrey' était aussi correcte mais elle apparaît plus  |
|    |tard dans la table).                                                                  |
|    |Voici un autre exemple :. fonctionne comme ceci. Supposons que la table user ressemble|
|    |à ceci :                                                                              |
|    |                                                                                      |
|    |                                                                                      |
|    |+----------------+----------+-                                                        |
|    || Host           | User     | ...                                                     |
|    |+----------------+----------+-                                                        |
|    || %              | jeffrey  | ...                                                     |
|    || thomas.loc.gov |          | ...                                                     |
|    |+----------------+----------+-                                                        |
|    |Une fois triée, la table ressemble à ceci :                                           |
|    |                                                                                      |
|    |                                                                                      |
|    |+----------------+----------+-                                                        |
|    || Host           | User     | ...                                                     |
|    |+----------------+----------+-                                                        |
|    || thomas.loc.gov |          | ...                                                     |
|    || %              | jeffrey  | ...                                                     |
|    |+----------------+----------+-                                                        |
|    |Une connexion par l'hôte thomas.loc.gov et l'utilisateur jeffrey utilisera la première|
|    |ligne, et la même connexion depuis whitehouse.gov utilisera la seconde.               |
|    |Une erreur commune est de penser que pour un nom d'utilisateur donné, toutes les      |
|    |lignes qui nomme explicitement cet utilisateur seront utilisées en premier par le     |
|    |serveur pour accepter la connexion. Ceci est tout simplement faux. L'exemple précédent|
|    |l'illustre bien : la connexion depuis thomas.loc.gov par jeffrey n'utilise par la     |
|    |ligne contenant l'utilisateur 'jeffrey' mais la ligne sans nom d'utilisateur.         |
|    |Si vous avez des problèmes à vous connecte au serveur, afficher la table user et trier|
|    |la à la main, pour savoir quelle ligne est la première a accepter votre connexion.    |
|    |6.8 Contrôle d'accès, étape 2 : vérification des requêtes                             |
|    |Une fois que la connexion est établie, le serveur passe en niveau 2. Pour chaque      |
|    |requête entrante, le serveur va vérifier que les droits sont suffisants pour effectuer|
|    |la requête, en fonction du type d'opération. C'est ici qu'interviennent les champs de |
|    |droits des tables de droits. Ces droits peuvent être stockés dans les tables user, db,|
|    |host, tables_priv ou columns_priv tables. Ces tables sont gérées gr?ce aux commandes  |
|    |GRANT et REVOKE. Reportez vous à la section Privileges, dans laquelle les champs de   |
|    |ces tables sont présentés).                                                           |
|    |Les droits pris en charge par la table user sont assignés globalement, et s'appliquent|
|    |quelque soit la base de données courante. Par exemple, si la table user donne les     |
|    |droits de delete, vous pouvez efface n'importe quelle base de donnée sur le serveur ! |
|    |! En d'autres termes, la table user fourni les droits de super utilisateur, et il est |
|    |avisé de ne donner ces droits qu'aux administrateurs du serveur. Pour les autres      |
|    |utilisateurs, il vaut mieux laisser les droits à 'N' et donner des droits spécifiques |
|    |sur les bases de données, avec les tables db et host.                                 |
|    |Les tables db et host donnent des droits spécifiques aux bases de données. Les valeurs|
|    |acceptées dans les champs sont les suivantes :                                        |
|    |Les caractères spéciaux ``%'' et ``_'' peuvent être utilisés dans les champs Host et  |
|    |Db de deux tables.                                                                    |
|    |Un '%' dans le champs Host de la table db signifie ``tous les hôtes.'' Une valeur vide|
|    |pour Host dans la table db signifie ``consulte la table host pour plus de détails.''  |
|    |Un '%' ou une chaîne vide dans le champs Host de la table host signifie `` tous les   |
|    |hôtes.''                                                                              |
|    |Un '%' ou une chaîne vide dans le champs Db dans l'une des tables signifie ``toutes   |
|    |les bases de données.''                                                               |
|    |une chaîne vide dans le champs User dans l'une des tables corresponde à l'utilisateur |
|    |anonyme.                                                                              |
|    |Les tables db et host sont lues et triées au démarrage du serveur (en même temps que  |
|    |la table user). La table db est triée en fonction des champs Host, Db et User, et la  |
|    |table host table est triée en fonction des champs Host Db. Tout comme pour la table   |
|    |user, le trie met les valeurs les plus précises en premier, puis le plus larges. Lors |
|    |de l'utilisation de la table, la première valeur qui correspond à l'utilisateur est   |
|    |utilisée.                                                                             |
|    |Les tables de droits tables_priv et columns_priv contiennent les droits spécifiques   |
|    |aux droits par table et par colonne. Les valeurs des champs peuvent être les suivantes|
|    |:                                                                                     |
|    |Les caractères spéciaux ``%'' et ``_'' peuvent être utilisés dans les champs Host et  |
|    |Db de deux tables.                                                                    |
|    |Un '%' ou une chaîne vide dans le Host de la table db signifie ``tous les hôtes.''    |
|    |Les champs Db, Table_name et Column_name ne peuvent pas contenir de champs vide, ou de|
|    |caractères spéciaux.                                                                  |
|    |Les tables tables_priv et columns_priv sont triées en fonction des champs Host, Db et |
|    |User. Le tri est identique à celui de la table db, mais étant donné que le champs Host|
|    |ne contient pas de caractère spéciaux, le tri est nettement plus simple.              |
|    |Le processus de vérification de requête est décrit ci-dessous. (Si vous êtes familier |
|    |avec la programmation de contrôle d'accès, vous remarquerez que la description qui    |
|    |suit est un peu simplifiée, par rapport aux algorithmes utilisés. En fait, la         |
|    |description est équivalente au code, et la différence sert simplement à rendre la     |
|    |description plus accessible).                                                         |
|    |Pour les requêtes administratives telles que shutdown, reload, etc..., le serveur ne  |
|    |vérifie les droits que dans la table user, étant donné que c'est la seule qui spécifie|
|    |les droits administratifs. La commande est exécutée si les droits sont disponibles, et|
|    |sinon, la requête n'est pas autorisée. Par exemple, si vous voulez exécuter mysqladmin|
|    |shutdown mais que votre compte utilisateur dans la table user n'a pas les droits de   |
|    |shutdown, l'autorisation n'est aps donnée, sans même vérifier les tables db ou host.  |
|    |(Etant donné que ces tables ne contiennent pas de colonne Shutdown_priv, il n'y a pas |
|    |besoin de passer en revue ces tables.)                                                |
|    |Pour les requêtes liées aux bases de données, telles que insert, update, etc., le     |
|    |serveur commence par vérifier les droits globaux (droits de super utilisateur) en     |
|    |recherchant dans la table user. Si il trouve des droits, l'exécution de la requête est|
|    |autorisé. Si les droits globaux sont insuffisants, le serveur détermine les droits    |
|    |spécifiques à cette base en vérifiant les tables db et host:                          |
|    |Le serveur dans la table db une ligne qui corresponde à Host, Db et User de           |
|    |l'utilisateur. Host et User ont été défini lors de la connexion au serveur. Le champs |
|    |Db prendre le nom de la base de données qui va être modifiée. Si il n'y a aucune      |
|    |entrée, l'autorisation n'est pas donnée.                                              |
|    |Si il y a une ligne, et que le champs Host n'est pas laissé vide, cette ligne définit |
|    |les droits de l'utilisateur, spécifiques à cette base.                                |
|    |Si le champs Host a été laissé vide, cela signifie que la table host contient la liste|
|    |des hôtes qui ont l'autorisation d'accéder à cette base. Dans ce cas, une nouvelle    |
|    |recherche est effectuée dans la table host pour rechercher une ligne qui correspondent|
|    |à Host et Db. Si aucune ligne n'est trouvée, alors l'accès n'est pas autorisé. Si une |
|    |ligne est trouvée, les droits d'accès de cet utilisateur sont représentés par         |
|    |l'intersection des droits issus de la table db et de la table host, i.e., c'est à dire|
|    |les droits qui sont à 'Y' dans les deux lignes trouvées. (De cette manière, vous      |
|    |pouvez donner des droits généraux, et restreindre sélectivement en fonction des hôtes,|
|    |gr?ce à la table host.)                                                               |
|    |Après avoir déterminé les droits spécifiques à la base de données, avec les tables db |
|    |et host, le serveur les ajoutent aux droits globaux donnés par la table user. Si le   |
|    |résultat de cette union autorise l'opération, la requête est exécutée. Sinon, le      |
|    |serveur vérifie les droits sur les tables et les colonnes dans les tables tables_priv |
|    |et columns_priv et les ajoutent aux droits de l'utilisateur. l'accès est alors donné  |
|    |ou retiré en fonction du résultat.                                                    |
|    |Exprimé par une formule booléenne, la description précédente du calcul des droits est |
|    |la suivante :                                                                         |
|    |                                                                                      |
|    |global privileges                                                                     |
|    |OR (database privileges AND host privileges)                                          |
|    |OR table privileges                                                                   |
|    |OR column privileges                                                                  |
|    |Il n'est pas évident que si les droits globaux user sont insuffisants pour l'opération|
|    |demandée, le serveur va les ajouter dans les différentes tables qui conservent les    |
|    |droits. La raison est qu'une requête peut nécessiter plusieurs droits différents. Par |
|    |exemple, la commande INSERT ... SELECT requiert les droits d'insertion (insert) et de |
|    |selection (select). Il se peut alors que les droits d'insertion soient disponible au  |
|    |niveau de la table, et que les droits de selection soient au niveau de la colonne.    |
|    |Dans ce cas, les droits de deux niveaux doivent être combinés pour autoriser la       |
|    |commande. D'o√π cette propagation de droits.                                           |
|    |La table host est utilisée pour avoir une liste de serveurs ``sécurisés''. A TcX, la  |
|    |table host contenait la liste de toutes les machines du réseau local. Toutes ces      |
|    |machines avaient des autorisations d'accès sur le serveur.                            |
|    |Vous pouvez aussi utiliser cette table pour lister les serveurs qui ne sont pas sûrs. |
|    |Par exemple, supposons que la machine public.votre.domaine soit située dans une zone  |
|    |publique qui ne soient pas sûre. Vous pouvez alors accepter tous les hôtes du réseau, |
|    |et exclure cette machine, comme ceci :                                                |
|    |                                                                                      |
|    |+----------------------+----+-                                                        |
|    || Host                 | Db | ...                                                     |
|    |+----------------------+----+-                                                        |
|    || public.votre.domaine | %  | ... (tous les droits à 'N')                             |
|    || %.your.domain        | %  | ... (tous les droits à 'Y')                             |
|    |+-------------------**-+----+-                                                        |
|    |Bien entendu, il est plus sage de tester toutes les lignes des tables de droits (e.g.,|
|    |en utilisant mysqlaccess) pour s'assurer que les droits sont bien donnés comme vous le|
|    |souhaitez.                                                                            |
|    |6.9 Prise en compte des modifications de droits                                       |
|    |Lorsque mysqld démarre, les tables de droits sont lu, et chargés en mémoire : ils sont|
|    |alors effectifs.                                                                      |
|    |Les modifications des tables de droits qui se font avec les requêtes GRANT, REVOKE, ou|
|    |SET PASSWORD sont immédiatement prises en compte.                                     |
|    |Si vous modifiez les tables de droits manuellement (INSERT, UPDATE, etc.), vous devrez|
|    |exécuter la commande FLUSH PRIVILEGES ou lancer mysqladmin flush-privileges pour      |
|    |indiquer au serveur qu'il faut qu'il relise les tables de droits. Sinon, les          |
|    |changements ne seront pas effectifs avant le prochain rechargement.                   |
|    |Lorsque le serveur remarque que les tables de droits ont été changées, les connexions |
|    |courantes sont traitées comme suit :                                                  |
|    |Les droits de table et de colonnes sont pris en compte à la prochaine requête.        |
|    |Les droits de base sont pris en compte à la prochaine utilisation de la requête USE   |
|    |nom_base_de_donnees.                                                                  |
|    |Les droits globaux et les mots de passes ne changent qu'à la prochaine connexion.     |
|    |6.10 Droits initiaux                                                                  |
|    |Après avoir installé MySQL, vous allez installer les premiers droits en exécutant     |
|    |l'utilitaire scripts/mysql_install_db. 4.7.1 Introduction à l'installation rapide. Le |
|    |script scripts/mysql_install_db démarre le serveur mysqld, puis initialise les tables |
|    |de droits, qui contiendront alors les droits suivants :                               |
|    |L'utilisateur MySQL root est créé, c'est le super utilisateur, investi de tous les    |
|    |droits. Les connexions au serveur MySQL doivent être faites depuis l'hôte local. NB:  |
|    |Le super utilisateur initial a un mot de passe vide ce qui fait que n'importe qui peut|
|    |se connecter sans mot de passe, et disposer de tous les droits.                       |
|    |Un utilisateur anonyme est aussi créé, qui peut travailler librement dans les bases de|
|    |données dont le nom commence par 'test_' et aussi 'test' . Les connections doivent    |
|    |être faites depuis l'hôte local. Cela signifie que quiconque se connecte depuis cet   |
|    |hôte peut être traité comme un utilisateur anonyme.                                   |
|    |Aucun autre droit n'est attribué. Par exemple, les utilisateurs normaux ne peuvent pas|
|    |utiliser mysqladmin shutdown ou mysqladmin processlist.                               |
|    |NB: Les droits par défaut sont différents sous Windows. 4.12.4 Faire tourner MySQL    |
|    |sous Win32.                                                                           |
|    |Etant donné que votre installation initialle est très ouverte, la première chose à    |
|    |faire est d'attribuer un mot de passe au root. Vous pouvez le faire simplement avec la|
|    |commande suivante :                                                                   |
|    |                                                                                      |
|    |shell> mysql -u root mysql                                                            |
|    |mysql> UPDATE user SET Password=PASSWORD(nouveau_mot_de_passe)                        |
|    |WHERE user='root';                                                                    |
|    |mysql> FLUSH PRIVILEGES;                                                              |
|    |Vous pouvez aussi utiliser la commande SET PASSWORD:                                  |
|    |                                                                                      |
|    |shell> mysql -u root mysql                                                            |
|    |mysql> SET PASSWORD FOR root=PASSWORD(nouveau_mot_de_passe);                          |
|    |Un autre moyen d'attribuer le mot de passe est de passer la commande mysqladmin:      |
|    |                                                                                      |
|    |shell> mysqladmin -u root password nouveau_mot_de_passe                               |
|    |Notez bien que si vous modifiez un mot de passe dans la table user directement avec la|
|    |première méthode, vous devez faire relire les tables par le serveur avec la commande  |
|    |FLUSH PRIVILEGES : dans le cas contraire, les modifications ne seront pas prises en   |
|    |compte.                                                                               |
|    |Une fois que le mot de passe du root a été affecté, vous devrez le fournir pour       |
|    |pouvoir vous connecter comme root.                                                    |
|    |Vous pouvez aussi laisser le mot de passe du root blanc, ce qui vous évitera d'avoir à|
|    |le spécifier lors de la connexion, surtout si vous faites d'autres tests              |
|    |d'installation. Sinon, n'oubliez pas d'en assigner un lors du passege en production,  |
|    |pour ne pas créer des trous de sécurité.                                              |
|    |Reportez vous au script scripts/mysql_install_db pour voir fonctionner les privilèges |
|    |par défaut. Vous pouvez utiliser ce script comme base, pour ajouter de nouveaux       |
|    |utilisateurs.                                                                         |
|    |Si vous voulez que les privilèges par défaut soient différents de ceux présentés      |
|    |jusqu'à présent, modifiez le script mysql_install_db avant de l'exécuter.             |
|    |Pour recréer les tables de droits, effacez les fichiers ``*.frm'', ``*.ISM'' et       |
|    |``*.ISD'' dans le dossier contenant le serveur mysql. (ce dossier est nommé ``mysql'' |
|    |dans le dossier du serveur. Ce dernier est affiché si avec la commande mysqld -help.  |
|    |Alors, exécutez le script mysql_install_db, éventuellement après avoir l'avoir édité. |
|    |NOTE IMPORTANTE : pour les versions de MySQL antérieures à 3.22.10, vous ne DEVEZ PAS |
|    |effacer les fichiers ``*.frm''. Si vous l'avez fait par accident, vous devez remettre |
|    |une copie (tirée de la distribution MySQL) avant d'exécuter mysql_install_db.         |
|    |6.11 Ajout d'un nouvel utilisateur MySQL                                              |
|    |Vous pouvez ajouter des utilisateurs de deux manières différentes : en utilisant la   |
|    |commande GRANT ou en manipulant directement les tables de droits MySQL. La meilleure  |
|    |méthode est l'utilisation de la commande GRANT, car elle est plus concise et est la   |
|    |source de moins d'erreur. Les exemples ci dessous montrent comment utiliser le client |
|    |mysql client pour ajouter un nouvel utilisateur. Ces exemples supposent que les droits|
|    |ont été créé comme décrit dans la section précédente. Cela signifie notamment que pour|
|    |faire des modifications, il vous faut être sur la machine qui fait tourner le serveur,|
|    |vous devez vous connecter en tant que root, et le root doit avoir les droits          |
|    |d'insertion et de rechargement (insert et reload ). De plus, si vous avez changé le   |
|    |mot de passe du root, vous devrez le spécifier pour pouvoir exécuter les commandes    |
|    |suivantes                                                                             |
|    |Ajout d'un nouvel utilisateur                                                         |
|    |                                                                                      |
|    |shell> mysql --user=root mysql                                                        |
|    |mysql> GRANT ALL PRIVILEGES ON *.* TO monty@localhost                                 |
|    |IDENTIFIED BY 'quelquechose' WITH GRANT OPTION;                                       |
|    |mysql> GRANT ALL PRIVILEGES ON *.* TO monty@"%"                                       |
|    |IDENTIFIED BY 'something' WITH GRANT OPTION;                                          |
|    |mysql> GRANT RELOAD,PROCESS ON *.* TO admin@localhost;                                |
|    |mysql> GRANT USAGE ON *.* TO dummy@localhost;                                         |
|    |Ces commandes ajoutent 3 nouveaux utilisateurs                                        |
|    |•  monty Un super-utilisateur avec les pleins pouvoirs, qui peut se connecter depuis  |
|    |n'importe quelle machine (même distante) mais qui doit utiliser le mot de passe       |
|    |'quelquechose' pour ce faire. Notez l'utilisation de la commande GRANT pour les deux  |
|    |formes monty@localhost et monty@"%". Si la ligne avec localhost n'est pas ajoutée     |
|    |l'utilisateur anonyme qui a été créé par le script mysql_install_db aura priorité lors|
|    |de la connexion, car il sera plus spécifique. Il faut donc l'ajouter nommément pour   |
|    |pouvoir donner les bons droits à monty.                                               |
|    |•  admin Un utilisateur qui peut se connecter depuis localhost sans mot de passe, et  |
|    |qui a les droits administratifs de reload et process. Cela va lui permettre d'exécuter|
|    |les utilitaires mysqladmin reload, mysqladmin refresh et mysqladmin flush-*, ainsi que|
|    |mysqladmin processlist . Aucun droit lié aux bases de données ne sont donnés. Ils     |
|    |pourront être donnés plus tard, avec des commandes GRANT.                             |
|    |•  dummy Un utilisateur qui peut se connecter sans mot de passe, mais uniquement      |
|    |depuis localhost . Les privilèges globaux sont tous à 'N' - le type spécial USAGE vous|
|    |permet de créer rapidement un utilisateur sans droits, et lui occtroyer plus tard.    |
|    |Vous pouvez aussi ajouter ces informations avec des commandes INSERT et en forcant le |
|    |serveur à recharger ces tables.                                                       |
|    |                                                                                      |
|    |shell> mysql --user=root mysql                                                        |
|    |mysql> INSERT INTO user VALUES('localhost','monty',PASSWORD('something'),             |
|    |'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y')                              |
|    |mysql> INSERT INTO user VALUES('%','monty',PASSWORD('something'),                     |
|    |'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y')                              |
|    |mysql> INSERT INTO user SET Host='localhost',User='admin',                            |
|    |Reload_priv='Y', Process_priv='Y';                                                    |
|    |mysql> INSERT INTO user (Host,User,Password)                                          |
|    |VALUES('localhost','dummy','');                                                       |
|    |mysql> FLUSH PRIVILEGES;                                                              |
|    |Suivant la version de MySQL, vous pouvez avoir un nombre différent de 'Y' dans les    |
|    |lignes ci-dessus (Les versions antérieures à 3.22.11 avaient moins de colonnes de     |
|    |droits.). Pour l'utilisateur admin, la version plus pratique de la commande INSERT est|
|    |disponible à partir de la version 3.22.11.                                            |
|    |Notez que pour créer un super utilisateur, il vous suffit de créer une ligne dans la  |
|    |table user avec tous les privilèges mis à 'Y' : aucune ligne n'est requise dans les   |
|    |tables db ou host.                                                                    |
|    |La colonne de droit dans la table user n'ont pas été explicitement fixée dans la      |
|    |dernière commande INSERT (pour l'utilisateur dummy), ce qui fait que ces colonnes ont |
|    |une valeur par défaut de 'N'. C'est le même comportement que pour la commande GRANT   |
|    |USAGE.                                                                                |
|    |L'exemple suivant ajoute un utilisateur custom qui peut se connecter depuis les hôtes |
|    |localhost, server.domain et whitehouse.gov. Il veut pouvoir accéder à la base de      |
|    |données bankaccount, mais uniquement depuis localhost, à la base expenses mais        |
|    |uniquement depuis whitehouse.gov et à la base customer depuis tous les hôtes Il veut  |
|    |avoir le même mot de passe pour toutes les connexions.                                |
|    |Pour donner ces droits à cet utilisateur, utilisez les commandes GRANT suivantes :    |
|    |                                                                                      |
|    |shell> mysql --user=root mysql                                                        |
|    |mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP                                  |
|    |ON bankaccount.*                                                                      |
|    |TO custom@localhost                                                                   |
|    |IDENTIFIED BY 'stupid';                                                               |
|    |mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP                                  |
|    |ON expenses.*                                                                         |
|    |TO [e-mail]                                                              |
|    |IDENTIFIED BY 'stupid';                                                               |
|    |mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP                                  |
|    |ON customer.*                                                                         |
|    |TO custom'%'                                                                          |
|    |IDENTIFIED BY 'stupid';                                                               |
|    |Pour donner ces droits à cet utilisateur en accédant directement aux tables de droits,|
|    |utilisez les commandes suivantes :                                                    |
|    |                                                                                      |
|    |shell> mysql --user=root mysql                                                        |
|    |mysql> INSERT INTO user (Host,User,Password)                                          |
|    |VALUES('localhost','custom',PASSWORD('stupid'));                                      |
|    |mysql> INSERT INTO user (Host,User,Password)                                          |
|    |VALUES('server.domain','custom',PASSWORD('stupid'));                                  |
|    |mysql> INSERT INTO user (Host,User,Password)                                          |
|    |VALUES('whitehouse.gov','custom',PASSWORD('stupid'));                                 |
|    |mysql> INSERT INTO db                                                                 |
|    |(Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,                        |
|    |Create_priv,Drop_priv)                                                                |
|    |VALUES                                                                                |
|    |('localhost','bankaccount','custom','Y','Y','Y','Y','Y','Y');                         |
|    |mysql> INSERT INTO db                                                                 |
|    |(Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,                        |
|    |Create_priv,Drop_priv)                                                                |
|    |VALUES                                                                                |
|    |('whitehouse.gov','expenses','custom','Y','Y','Y','Y','Y','Y');                       |
|    |mysql> INSERT INTO db                                                                 |
|    |(Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,                        |
|    |Create_priv,Drop_priv)                                                                |
|    |VALUES('%','customer','custom','Y','Y','Y','Y','Y','Y');                              |
|    |mysql> FLUSH PRIVILEGES;                                                              |
|    |Les trois premières insertions ajoutent des lignes dans la table user pour autoriser  |
|    |la connexion de custom depuis les divers sites qu'il désire, mais ne lui donne aucune |
|    |permission. (tous ses droits sont à 'N'). Les trois insertions suivantes ajoutent des |
|    |lignes dans la table db pour donner des droits sur les bases bankaccount, expenses et |
|    |customer, mais uniquement pour des connexions avec des hôtes autorisés. Et, comme     |
|    |toujours lorsqu'on touche aux tables de droits, le serveur doit les recharger (avec   |
|    |FLUSH PRIVILEGES) pour les prendre en compte.                                         |
|    |Si vous désirez donner un droit spécifique à un utilisateur donnée, mais depuis       |
|    |n'importe quel hôte, utilisez la commande GRANT suivante :                            |
|    |                                                                                      |
|    |mysql> GRANT ...                                                                      |
|    |ON *.*                                                                                |
|    |TO myusername@"%.mydomainname.com"                                                    |
|    |IDENTIFIED BY 'mypassword';                                                           |
|    |Pour faire la même chose avec une attaque directe des tables, faites ceci :           |
|    |                                                                                      |
|    |mysql> INSERT INTO user VALUES ('%.mydomainname.com', 'myusername',                   |
|    |PASSWORD('mypassword'),...);                                                          |
|    |mysql> FLUSH PRIVILEGES;                                                              |
|    |Vous pouvez aussi utiliser xmysqladmin, mysql_webadmin et even xmysql pour insérer,   |
|    |modifier des valeurs dans les tables de droits. Vous pouvez trouvez ces utilitaires à |
|    |http://www.mysql.com/Contrib/.                                                        |
|    |6.12 Comment affecter les mots de passe                                               |
|    |Les exemples des sections précédentes illustre un principe important : lorsque vous   |
|    |enregistrez des mots de passe non vide avec les commandes INSERT ou UPDATE, vous devez|
|    |utiliser la fonction PASSWORD() pour l'encrypter. En effet, la table user conserve les|
|    |mots de passe sous forme cryptée, et non pas en clair. Si vous oubliez ceci, vous     |
|    |pouvez vous retrouver avec des mots de passes tels que :                              |
|    |                                                                                      |
|    |shell> mysql -u root mysql                                                            |
|    |mysql> INSERT INTO user (Host,User,Password)                                          |
|    |VALUES('%','jeffrey','biscuit');                                                      |
|    |mysql> FLUSH PRIVILEGES;                                                              |
|    |Le résultat est que la valeur en clair 'biscuit' est enregistrée dans la table user.  |
|    |Lorsque l'utilisateur jeffrey va tenter de se connecter au serveur, le client mysql va|
|    |crypter le mot de passe qui lui est fourni avec PASSWORD(), et l'envoyer au serveur.  |
|    |Le serveur compare alors la valeur qui est stockées (qui est en clair 'biscuit') avec |
|    |la même valeur, mais encryptée (qui ne sera pas 'biscuit'). La comparaison échoue, et |
|    |le serveur rejette al connexion.                                                      |
|    |                                                                                      |
|    |shell> mysql -u jeffrey -pbiscuit test                                                |
|    |Access denied                                                                         |
|    |Etant donné que les mots de passe doivent être crypté lorsqu'ils sont inséré dans la  |
|    |table user, la commande INSERT doit être spécifié comme suit :                        |
|    |                                                                                      |
|    |mysql> INSERT INTO user (Host,User,Password)                                          |
|    |VALUES('%','jeffrey',PASSWORD('biscuit'));                                            |
|    |Vous devez utiliser la fonction PASSWORD() lorsque vous utilisez la clause SET        |
|    |PASSWORD:                                                                             |
|    |                                                                                      |
|    |mysql> SET PASSWORD FOR jeffrey@"%" = PASSWORD('biscuit');                            |
|    |Si vous ajoutez un mot de passe avec la commande GRANT ... IDENTIFIED BY ou avec la   |
|    |commande mysqladmin password, la fonction PASSWORD() n'est pas nécessaire. Ces deux   |
|    |méthodes crypte le mot de passe pour vous :                                           |
|    |                                                                                      |
|    |mysql> GRANT USAGE ON *.* TO jeffrey@"%" IDENTIFIED BY 'biscuit';                     |
|    |or                                                                                    |
|    |                                                                                      |
|    |shell> mysqladmin -u jeffrey password biscuit                                         |
|    |Note: PASSWORD() dispose d'une encryption qui n'est pas la même que sous Unix. Il ne  |
|    |faut pas supposer que le mot de passe Unix et MySQL sont les mêmes, même si PASSWORD()|
|    |retourne la même valeur que celle qui est stockée dans le fichier de mot de passe de  |
|    |Unix. 6.2 Noms et mot de passe des d'utilisateurs MySQL.                              |
|    |6.13 Causes des erreurs "Access denied"                                               |
|    |L'erreur " Access denied " (accès refusé) peut survenir lors d'une tentative de       |
|    |connexion à MySQL. Voici une liste de problème type qui peuvent être la cause d'un tel|
|    |comportement, et leur solution :                                                      |
|    |Avez vous exécuté le script mysql_install_db après avoir installé MySQL, pour créer   |
|    |les premières lignes dans les tables de droits ? Si non, faites le. 6.10 Droits       |
|    |initiaux. Testez les droits initaux en exécutant la commande suivante :               |
|    |                                                                                      |
|    |shell> mysql -u root test                                                             |
|    |Le serveur doit vous autoriser la connexion sans erreur. Assurez vous aussi que vous  |
|    |avez un fichier appelé ``user.ISD'' dans le dossier de MySQL. Généralement, il se     |
|    |trouve là : ``PATH/var/mysql/user.ISD'', Avec PATH qui représente le chemin jusqu'à la|
|    |racine de l'installation de MySQL.                                                    |
|    |Après une installation, il vaut mieux vous connecter au serveur, et mettre en place   |
|    |des utilisateurs et leur permissions.                                                 |
|    |                                                                                      |
|    |shell> mysql -u root mysql                                                            |
|    |Le serveur autorisera la connexion car l'utilisateur MySQL root n'a pas de mot de     |
|    |passe à l'origine. Etant donné que cela crée un gros risque au niveau de la sécurité  |
|    |de la base, affecter un mot de passe à l'utilisateur root doit être une priorité      |
|    |lorsque vous créez les utilisateurs de votre serveur. Si, lors de la connexion en tant|
|    |que root , vous obtenez l'erreur suivante :                                           |
|    |                                                                                      |
|    |Access denied for user: '@unknown' to database mysql                                  |
|    |Cela signifie que vous n'avez pas de ligne dans la table user avec la valeur 'root'   |
|    |dans la colonne User et que mysqld n'a pas pu trouver votre hôte dans cette table.    |
|    |Dans ce cas, vous devez redémarrer le serveur avec l'option --skip-grant-tables et    |
|    |éditer les fichiers ``/etc/hosts'' ou ``\windows\hosts'' pour ajouter une ligne pour  |
|    |votre hôte.                                                                           |
|    |Si vous avez fait la mise à jour depuis une version antérieure à 3.22.11 vers une     |
|    |version 3.22.11 ou plus récente, avez vous exécuté le script                          |
|    |mysql_fix_privilege_tables? Si non, faites le. La structure des tables de droits a    |
|    |évolé avec la version 3.22.11 lorsque la commande GRANT a été ajoutée.                |
|    |Si vous avez modifié directement la table de droit (avec les commandes INSERT ou      |
|    |UPDATE) et que vos modifications n'ont pas été prise en compte, n'oubliez pas qu'il   |
|    |faut exécuter une commande FLUSH PRIVILEGES ou mysqladmin flush-privileges pour forcer|
|    |le serveur à recharger les nouvelles valeurs. Sinon, vos modifications n'auront pas   |
|    |d'effet jusqu'au prochain redémarrage du serveur. N'oubliez pas qu'après avoir modifié|
|    |votre mot de passe root, vous n'avez pas à le re entrer jusqu'à ce que vous exécutiez |
|    |la commande FLUSH PRIVILEGES car le serveur n'a pas encore noté que vous l'aviez      |
|    |modifié !                                                                             |
|    |Si les droits semblent changer durant une session, c'est peut être qu'un super        |
|    |utilisateur les a changé. Recharger les droits affecte non seulement les nouvelles    |
|    |connexions, mais aussi les connexions en cours, comme précisé dans section 6.9 Prise  |
|    |en compte des modifications de droits.                                                |
|    |A fin de tests, démarrez le serveur mysqld avec l'option --skip-grant-tables. Ensuite,|
|    |vous pouvez changer les tables de droits MySQL et utiliser le script mysqlaccess pour |
|    |vérifier si les modifications ont bien l'effet désiré. Lorsque vous avez fini, lancez |
|    |la commande flush-privileges pour forcer l'utilisation des nouvelles tables de droits.|
|    |Note: Recharger les tables annule l'option --skip-grant-tables. Cela vous permet de   |
|    |dire au serveur quand commencer à utiliser les droits, sans le redémarrer.            |
|    |Si vous avez des problèmes d'accès avec un programme Perl, Python ou ODBC, essayez de |
|    |vous connecter au serveur avec mysql -u user_name nom_base_de_donnees ou mysql -u     |
|    |user_name -pyour_pass nom_base_de_donnees. Si vous etes capable de vous connecter avec|
|    |le client mysql, c'est qu'il y a un problème avec votre programme, et non pas dans les|
|    |droits d'accès.. (Notez aussi qu'il n'y a pas d'espace entre l'option -p et le mot de |
|    |passe. Alternativement, vous pouvez utiliser --password=your_pass pour spécifier votre|
|    |mot de passe.)                                                                        |
|    |Si vous êtes bloqué par votre mot de passe, pensez à utiliser la fonction PASSWORD()  |
|    |pour changer de mot de passe avec les commandes INSERT, UPDATE ou SET PASSWORD. Cette |
|    |fonction n'est pas nécessaire avec la commande GRANT ... INDENTIFIED BY ou avec la    |
|    |syntaxe mysqladmin password. Reportez vous à la section Passwords                     |
|    |localhost est un synonyme qui désigne votre machine locale, ou l'hôte de connexion par|
|    |défaut. Cependant, les connexions à localhost ne sont pas valables si vous utilisez   |
|    |MIT-pthreads (Les connexions localhost utilisent les sockets Unix, qui ne sont pas    |
|    |supportées par MIT-pthreads). Pour contourner le problème sur ces systèmes, il        |
|    |préférable d'utiliser l'option --host pour spécifier explicitement le nom de l'hôte.  |
|    |Cela va forcer le type de la connexion à TCP/IP. Dans ce cas, vous devez utiliser le  |
|    |vrai nom d'hôte de votre machine, et l'inscrire dans la table user (Cela reste vrai   |
|    |même si vous exécutez un programme client sur la même machine que le serveur).        |
|    |Si vous avez l'erreur Access denied lors d'une connexion au serveur avec l'option -u  |
|    |user_name nom_base_de_donnees, vous pouvez avoir un problème avec la talbe user.      |
|    |Vérifiez ceci en exécutant la commande mysql -u root mysql puis la commande sui vante |
|    |:                                                                                     |
|    |                                                                                      |
|    |mysql> SELECT * FROM user;                                                            |
|    |Le résultat devrait contenir une ligne dont les colonnes Host et User correspondent au|
|    |nom d'hôte de votre ordinateur et au nom d'utilisateur MySQL.                         |
|    |Le message Access denied apparaîtra si vous essayez de vous connecter, le message     |
|    |d'erreur affichera l'adresse de l'hôte de connexion, le nom d'utilisateur et si vous  |
|    |utilisez un mot de passe. Normalement, il ne devrait y avoir qu'une ligne de la user  |
|    |qui corresponde exactement au nom d'hôte de votre ordinateur et au nom d'utilisateur  |
|    |Si vous obtenez l'erreur ci dessous lors de la connexion au serveur depuis une autre  |
|    |machine que celle qui heberge le serveur MySQL, c'est qu'il manque une ligne dans la  |
|    |table user pour décrire votre machine hôte :                                          |
|    |                                                                                      |
|    |Host ... is not allowed to connect to this MySQL server                               |
|    |Vous pouvez régler ce problème en utilisant l'utilitaire mysql (sur la machine server |
|    |! !) pour ajouter une ligne dans la table user pour le nom d'hôte de votre ordinateur |
|    |et le nom d'utilisateur. Si vous ne fonctionnez pas sous MySQL 3.22 et que vous ne    |
|    |savez pas quelle adresse IP ou quel nom d'hôte est celui de votre machine, il vaut    |
|    |mieux ajouter une ligne avec '%' dans la colonne Host et redémarrer le serveur avec   |
|    |l'option --log option. Après avoir tenté de vous connecter depuis la machine client,  |
|    |l'historique vous indiquera qui s'est réellement connecté. Vous pouvez alors remplacer|
|    |la ligne avec '%' de la table user par une ligne plus spécifique. Sinon, cela peut    |
|    |créer un trou de sécurité.                                                            |
|    |Si le test avec mysql -u root test fonctionne mais que mysql -h your_hostname -u root |
|    |test retourne une erreur Access denied, alors c'est que vous n'avez pas entrer le nom |
|    |de votre hôte dans la table user. Un problème récurent est que la colonne Host de la  |
|    |table user contient un nom d'hôte général, mais la résolution de nom retourne un nom  |
|    |de domaine complet, et vice-versa. Par exemple, si vous avec une ligne qui contient   |
|    |'tcx' dans la table user, mais que votre DNS dit à MySQL que votre nom d'hôte est     |
|    |'tcx.subnet.se', la ligne ne correspondra pas. Essayez d'ajouter une ligne dans la    |
|    |table user qui contienne l'adresse IP numérique de votre hôte, dans la colonne Host.  |
|    |(Alternativement vous pouvez aussi ajouter une ligne dans la table user avec une      |
|    |valeur dans la colonne Host qui contienne un caractère joker (par exemple, 'tcx.%').  |
|    |Cependant, c'est une pratique non sécurisée, qui peut provoquer des problèmes de      |
|    |sécurité.                                                                             |
|    |Si mysql -u user_name test fonctionne mais mysql -u user_name                         |
|    |other_nom_base_de_donnees ne fonctionne pas, c'est que vous n'avez pas d'entrée pour  |
|    |la colonne other_nom_base_de_donnees de la table db.                                  |
|    |Si mysql -u user_name nom_base_de_donnees fonctionne lorsqui'il est exécuté sur la    |
|    |machine server, mais que mysql -u host_name -u user_name nom_base_de_donnees ne       |
|    |fonctionne pas lorsqu'il est utilisé sur une machine client, c'est que la machine     |
|    |client n'est pas listée dans la table user ou la table db.                            |
|    |Si vous n'arrivez pas à vous defaire de l'erreur Access denied, effacez toutes les    |
|    |lignes de la table user qui possède un joker (``%'' ou ``_')'dans la colonne Host. Une|
|    |erreur récurrente est d'insérer une ligne du type Host='%' et User='quidam', en       |
|    |pensant que cela va vous permettre de vous connecter depuis la machine localhost. La  |
|    |raison qui fait que ceci ne fonctionne pas est que les droits par défaut contiennent  |
|    |une ligne qui est Host='localhost' et User=''. Or, la ligne qui a Host ='localhost'   |
|    |est plus spécifique que '%', et donc, sera utilisée de préférence à celle utilisée    |
|    |lors de la connexion de depuis localhost! La procedure correcte est d'insérer un      |
|    |deuxième ligne avec Host='localhost' et User='some_user', ou d'effacer les lignes avec|
|    |Host='localhost' et User=''.                                                          |
|    |Si vous avez l'erreur suivante, c'est que vous avez un problème avec la table db ou   |
|    |host:                                                                                 |
|    |                                                                                      |
|    |Access to database denied                                                             |
|    |Si l'entrée sélectionnée dans la table db a une colonne Host vide, assurezvous qu'il y|
|    |a au moins une entrée correspondante dans la table host qyu spécifie à quel hôte      |
|    |s'applique ces droits. Si vous avez une erreur en utilisant la commande SELECT ...    |
|    |INTO OUTFILE or LOAD DATA INFILE, c'est que vous n'avez peut être pas les droits file.|
|    |                                                                                      |
|    |Rappelez vous que les programmes clients utilisent des paramètres par défaut qui sont |
|    |stockés dans des fichiers de configuration ou des variables d'environnement. Si un    |
|    |client semble ne pas envoyer les bons paramètres lorsque vous ne les spécifiez pas,   |
|    |allez vérifier les informations stockées dans le fichier ``.my.cnf'' de votre dossier |
|    |racine, ou les variables d'environnment. Vous pouvez aussi vérifier les paramètres    |
|    |dans les fichiers de configuration de MySQL, mais il est très improbable que des      |
|    |paramètres de connexion soient enregistrés là. 4.15.4 Fichier d'options.              |
|    |Si tout ce qui précède a échoué, lancez le démon mysqld avec les options de debugging |
|    |(par exemple, --debug=d,general,query). Cette option affichera les hôtes et nom       |
|    |d'utilisateur des connexions, ainsi que des informations concernant les commandes     |
|    |exécutées. Reportez vous à la section G.1 Debugguer un serveur MySQL.                 |
|    |Si vous avez vraiment tout tenté, et que vous pensez qu'il vous faut le rapporter à la|
|    |liste de diffusion (en anglais), n'oubliez jamais de fournir un dump des tables de    |
|    |droits de MySQL. Vous pouvez créer ce dump avec l'utilitaire mysqldump mysql. Comme   |
|    |toujours, pensez à poster votre problème avec l'utilitaire mysqlbug. Dans certains    |
|    |cas, vous devrez redémarrer mysqld avec l'option --skip-grant-tables pour pouvoir     |
|    |faire le dump.                                                                        |
|    |6.14 Comment protéger MySQL contre les hackers                                        |
|    |Lorsque vous vous connectez à un serveur MySQL, vous utiliserez en règle générale un  |
|    |mot de passe. Le mot de passe sera transmis crypté lors de la connexion, et non pas en|
|    |clair.                                                                                |
|    |Toutes les informations suivantes seront transmises en clair, ce qui fait que         |
|    |quiconque observe la connexion peut lire les informations. Si vous êtes concerné par  |
|    |les problèmes de sécurité, vous pouvez utiliser le protocole compressé (à partir de   |
|    |MySQL 3.22) pour rendre les choses plus difficile. Pour complexifier encore la        |
|    |lecture, vous pouvez installer ssh (http://www.cs.hut.fi/ssh). Ce protocol fourni un  |
|    |cryptage de la connexion TCP/IP entre le client MySQL et me serveur MySQL.            |
|    |Pour sécuriser un système MySQL, il est fortement recommandé de suivre les            |
|    |recommandations suivantes :                                                           |
|    |Utilisez des mots de passe pour TOUT les utilisateurs MySQL. N'oubliez pas qu'il est  |
|    |très facile de se connecter à la place d'un autre avec la commande mysql -u other_user|
|    |nom_base_de_donnees si other_user n'a pas de mot de passe. C'est une stratégie        |
|    |standard dans les applications clients/serveur. Vous pouvez changer les mots de passe |
|    |de tous les utilisateurs en éditant le script mysql_install_db puis en l'exécutant, ou|
|    |bien avec la commande root suivante :                                                 |
|    |                                                                                      |
|    |shell> mysql -u root mysql                                                            |
|    |mysql> UPDATE user SET Password=PASSWORD('new_password')                              |
|    |WHERE user='root';                                                                    |
|    |mysql> FLUSH PRIVILEGES;                                                              |
|    |N'utilisez pas MySQL comme un démon du root Unix. mysqld peut être exécuté par        |
|    |n'importe quel utilisateur. Vous pouvez aussi créer un nouvel utilisateur mysql       |
|    |augmenter la sécurité. Si vous utilisez mysqld à partir d'un compte Unix autre que le |
|    |root, vous n'avez pas à changer l'utilisateur the root dans la table user, car les    |
|    |noms d'utilisateur MySQL n'ont rien à voir avec ceux d'Unix. Vous pouvez éditer le    |
|    |script mysql.server pour lancer mysqld avec un autre utilisateur. Généralement, on le |
|    |fait avec la commande su. Pour plus de détails, @pref{Changing MySQL user}.           |
|    |Si vous avez mis le mot de passe du root Unix dans le script mysql.server, assurez    |
|    |vous que ce fichier n'est lisible que par le root.                                    |
|    |Vérifiez que l'utilisateur Unix qui exécute mysqld est le seul à avoir les droits     |
|    |d'écriture / lecture dans le dossier des bases de données.                            |
|    |Ne donnez le droit de process que très parcimonieusement. L'affichage de la fonction  |
|    |mysqladmin processlist dévoile le texte de toutes les commandes en cours d'exécution, |
|    |ce qui fait que tout ceux qui ont ce droit, ont vue sur les commandes du type UPDATE  |
|    |user SET password=PASSWORD('not_secure'). mysqld garde toujours une connexion de libre|
|    |pour les utilisateurs qui ont le droit de process, afin que le root MySQL puisse      |
|    |toujours se connecter et s'assurer du bon fonctionnement des connexions en cours.     |
|    |Ne donnez le droit de file que très parcimonieusement donnez. Quiconque a un tel droit|
|    |peut écrire un fichier n'importe ou dans le système de fichier, et notamment dans les |
|    |tables de droits de mysqld! Pour sécuriser un peu ceci, tous les fichiers généré par  |
|    |SELECT ... INTO OUTFILE ne sont lisibles par tous, mais non modifiables. Le droit de  |
|    |file peut aussi être utilisé pour lire un fichier quelconque sur le serveur. Cela     |
|    |permet notamment de lire le fichier ``/etc/passwd'' dans une table, et de le lire avec|
|    |SELECT.                                                                               |
|    |Si vous n'avez pas confiance dans votre serveur DNS, il vaut mieux utiliser les       |
|    |adresse IP numériques, à la place des noms d'hôtes. En principe, l'option --secure de |
|    |mysqld devrait être suffisante pour sécuriser les noms d'hôtes. Dans toues les cas,   |
|    |méfiez vous des jokers dans les noms d'hôtes.                                         |
|    |Les options suivantes affectent la sécurité :                                         |
|    |•  --secure Les adresse IP retournées par l'appel système gethostbyname() sont        |
|    |vérifiées pour s'assurer qu'elle correspondent bien à l'hôte original. Cela rend plus |
|    |difficile de simuler un hôte. Cette option effectue aussi un nettoyage hygiénique des |
|    |hôtes. Cette option a été enlevée par défaut dans la version MySQL 3.21 car elle peut |
|    |ralentir le serveur, à cause du temps de résolution. MySQL 3.22 conserve les noms     |
|    |d'hôtes qu'il a déjà résolu dans un cache.                                            |
|    |•  --skip-grant-tables Cette option indique au serveur qu'il ne doit pas utiliser les |
|    |droits enregistrés. Cela donne à tous un accès complet à toutes les bases. (Vous      |
|    |pouvez aussi charger les tables d'un serveur en fonctionnement avec la commande       |
|    |mysqladmin reload.)                                                                   |
|    |•  --skip-name-resolve Les noms d'hôtes ne sont pas résolus. Toutes les lignes de la  |
|    |table Host doivent contenir des valeurs nuémriques, ou bien localhost.                |
|    |•  --skip-networking N'accepte pas les connexions TCP/. Toutes les connexions à mysqld|
|    |doivent être faites avec les sockets Unix. Cette option n'est pas disponibles pour les|
|    |systèmes qui utilisent les MIT-pthreads, car MIT-pthreads ne supporte pas les sockets |
|    |Unix.                                                                                 |
|    |7 Programmation MySQL                                                                 |
|    |7.1 Syntaxe des chaînes et nombres                                                    |
|    |7.1.1 Chaînes                                                                         |
|    |Une chaîne est une séquence de caractères, entourée par des guillemets simples (`''') |
|    |ou doubles(`""'). Par exemple :                                                       |
|    |                                                                                      |
|    |'une chaîne'                                                                          |
|    |"une autre chaîne"                                                                    |
|    |A l'intérieur d'une chaîne, on trouve des séquences spéciales. Celles-ci commencent   |
|    |avec le caractère backslash (``\''), dit aussi caractère d'échappement. MySQL         |
|    |reconnaît les séquences suivantes :                                                   |
|    |Within a string, certain sequences have special meaning. Each of these sequences      |
|    |begins with a backslash known as the escape character. MySQL recognizes the following |
|    |escape sequences:                                                                     |
|    |•  \0 ASCII 0 (NUL) le caractère nul.                                                 |
|    |•  \n Une nouvelle ligne.                                                             |
|    |•  \t Une tabulation.                                                                 |
|    |•  \r Un retour chariot.                                                              |
|    |•  \b Un effacement.                                                                  |
|    |•  \' Un guillemet simple (``''').                                                    |
|    |•  \" Un guillemet double (``"'').                                                    |
|    |•  \\ Un backslash (``\'').                                                           |
|    |•  \% Un pourcentage ``%''. Cela permet de rechercher le caractère `%' dans un        |
|    |contexte ou il pourrait etre considéré comme un caractère spécial.                    |
|    |•  \_ Un souligné ``_'' Cela permet de rechercher le caractère ``_'dans un contexte ou|
|    |il pourrait etre considéré comme un caractère spécial.'                               |
|    |Il y a plusieurs façons d'introduire des guillemets dans une chaîne.                  |
|    |Un guillemet simple ``''' dans une chaîne à guillemet simple peut s'écrire : ``''''.  |
|    |Un guillemet double ``"''dans une chaîne à double simple peut s'écrire : ``""''.      |
|    |On peut ajouter le caractère d'échappement avant un guillemet : ``\''.                |
|    |Un guillemet simple ``''' dans une chaîne à guillemet double ne requiert aucun        |
|    |traitement spécial.                                                                   |
|    |Un guillemet double ``"'' dans une chaîne à guillemet simple ne requiert aucun        |
|    |traitement spécial.                                                                   |
|    |La commande SELECT ci-dessous montre comment fonctionne les guillemets et le caractère|
|    |d'échappement.                                                                        |
|    |mysql> SELECT 'bonjour', '"bonjour"', '""bonjour""', 'bonj''our', '\'bonjour';        |
|    |                                                                                      |
|    |+---------+-----------+-------------+----------+----------+                           |
|    || bonjour | "bonjour" | ""bonjour"" | bonj'our | 'bonjour |                           |
|    |+---------+-----------+-------------+----------+----------+                           |
|    |mysql> SELECT "bonjour", "'bonjour'", "''bonjour''", "bonj""our", "\"bonjour";        |
|    |+---------+-----------+-------------+----------+----------+                           |
|    || bonjour | 'bonjour' | ''bonjour'' | bonj"our | "bonjour |                           |
|    |+---------+-----------+-------------+----------+----------+                           |
|    |                                                                                      |
|    |mysql> SELECT "Voici\nQuatre\nLignes\nDistinctes";                                    |
|    |+--------------------+                                                                |
|    || Voici                                                                               |
|    |Quatre                                                                                |
|    |Lignes                                                                                |
|    |Distinctes |                                                                          |
|    |+--------------------+                                                                |
|    |Pour ajouter des valeurs binaires dans un BLOB, les caractères suivants doivent être  |
|    |représenté par des séquences spéciales :                                              |
|    |•  NUL ASCII 0. Représentation : ``\0'' (un backslash et un caractère ASCII ``0'' ).  |
|    |•  \ ASCII 92, backslash. Représentation : ``\\''.                                    |
|    |•  ' ASCII 39, guillemet simple. Représentation : ``\'''.                             |
|    |•  " ASCII 34, guillemet double. Représentation : ``\"''.                             |
|    |•  De préférence, on utilisera une séquence d'échappement pour toute chaîne qui       |
|    |contient un des caractères spéciaux ci-dessus.                                        |
|    |7.1.2 Nombres                                                                         |
|    |•  Les entiers sont représentés comme une séquence de chiffres. Les nombres réel      |
|    |utilise le point (``.') comme séparateur décimal. Les entiers et les réels peuvent    |
|    |être précédés par le signe moins (`-'), pour indiquer un nombre négatif.'             |
|    |•  Exemples d'entiers :                                                               |
|    |                                                                                      |
|    |1221                                                                                  |
|    |0                                                                                     |
|    |-32                                                                                   |
|    |•  Exemples de nombres réels :                                                        |
|    |                                                                                      |
|    |294.42                                                                                |
|    |-32032.6809e+10                                                                       |
|    |148.00                                                                                |
|    |•  Lorsqu'un nombre entier est utilisé avec un nombre réel, il est considéré lui      |
|    |aussi, comme un nombre réel.                                                          |
|    |7.1.3 Valeurs héxadecimales                                                           |
|    |MySQL supporte les valeurs hexadécimales. Dans un contexte numérique, elles se        |
|    |comportent comme des entiers (précision 64bits). Dans un contexte de chaînes, elles se|
|    |comportent comme des chaînes binaires dont chaque paire de digits seront converti en  |
|    |caractère.                                                                            |
|    |                                                                                      |
|    |mysql> SELECT 0xa+0                                                                   |
|    |-> 10                                                                                 |
|    |mysql> select 0x5061756c;                                                             |
|    |-> Paul                                                                               |
|    |Les chaînes hexadécimales sont souvent utilisées avec ODBC pour donner des valeurs aux|
|    |colonnes BLOB.                                                                        |
|    |7.1.4 La valeur NULL                                                                  |
|    |•  La valeur NULL signifie : ``aucune information''. Cette valeur est différente de 0 |
|    |ou de la chaîne vide.                                                                 |
|    |•  NULL est parfois représenté par \N quand on utilise un fichier d'import ou d'export|
|    |(LOAD DATA INFILE, SELECT ... INTO OUTFILE). Cf section LOAD DATA.                    |
|    |7.1.5 Noms de base de données, table, index, column et alias                          |
|    |•  Les noms portés par les base de données, les tables, les index, les colonnes et les|
|    |alias suivent tous les mêmes règle dans MySQL:                                        |
|    |                                                                                      |
|    |Un nom est constitué de caractères alphanumériques et des caractères ``_'' et ``$''.  |
|    |                                                                                      |
|    |Le nom d'une base de données, d'une table, d'un index ou d'une colonne peut avoir     |
|    |jusqu'à 64 caractères.                                                                |
|    |Un nom peut commencer avec n'importe quel caractère autorisé. En particulier, un nom  |
|    |peut commencer avec un nombre (ce qui n'est pas toujours le cas dans de nombreuses    |
|    |bases de données). Cependant, un nom ne peut pas contenir uniquement des nombres.     |
|    |Il est préférable de ne pas utiliser de noms tels que 1e, car un expression telle que |
|    |1e est ambiguë. Le nom peut être interprété comme une expression (1e + 1) ou comme le |
|    |nombre 1e+1.                                                                          |
|    |Il est interdit d'utiliser le point dans les noms, car il est déjà utilisé pour       |
|    |spécifier les noms des colonnes (cf ci dessous).                                      |
|    |Avec MySQL, il est possible d'accéder aux colonnes d'une table avec les expressions   |
|    |suivantes : Il n'est pas nécessaire de préciser Nom_tab ou Nom_base. Nom_tab pour     |
|    |faire référence à un nom de colonne, à moins que cela puisse être ambiguë. Par        |
|    |exemple, si les tables t1 et t2 contiennent chacune la colonne c, et que lors d'un    |
|    |SELECT, les deux tables soient utilisées. Dans ce cas, c est ambiguë, car elle n'est  |
|    |pas unique dans les tables utilisées, et il faut alors préciser la colonne en         |
|    |précisant t1.c et t2.c. De la même manière, si deux bases de données contiennent      |
|    |chacune une table nommée t, il faudra préciser la base de données utilisée, en notant |
|    |: db1.t.col1 et db2.t.col2. Dans la syntaxe .Nom_tab. Nom_col, on suppose que la table|
|    |Nom_tab est disponible dans la base de données courante. Cette syntaxe est autorisée  |
|    |pour assurer la compatibilité avec ODBC, car certains programmes compatible ODBC      |
|    |ajoute le préfixe point ``.'' aux noms des tables.                                    |
|    |7.1.5.1 Sensibilité des noms à la casse                                               |
|    |•  Dans MySQL, les base de données et les tables correspondent à des dossiers et      |
|    |fichiers. Par conséquent, la sensibilité à la casse du système d'exploitation         |
|    |sous-jacent détermine celle de MySQL. Par exemple, les noms de base de données et de  |
|    |tables seront sensible à la casse sous Unix, et pas sous Windows.                     |
|    |•  N.B.: Bien que les noms de base de données et de table soient insensible à la      |
|    |casse, sous Windows 32bits, il est préférable de toujours utiliser la même casse pour |
|    |se référer à un objet dans une même requête. La requête suivante ne fonctionnera pas, |
|    |car on utilise la même table avec deux noms différents : ma_table et MA_TABLE.        |
|    |                                                                                      |
|    |                                                                                      |
|    |SELECT * FROM ma_table WHERE MA_TABLE.col=1;                                          |
|    |•  Dans tous les cas, les noms de colonnes sont insensibles à la casse.               |
|    |•  Les noms d'alias sont sensibles à la casse. La requête suivante ne fonctionnera    |
|    |pas, car elle utilise le même alias, sous la forme : a et A.                          |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> SELECT Nom_col FROM Nom_table AS a                                             |
|    |WHERE a.Nom_col = 1 OR A. Nom_col = 2;                                                |
|    |•  Les alias sur une colonnes sont insensibles à la casse.                            |
|    |7.2 Types de colonnes                                                                 |
|    |•  MySQL dispose d'un grand nombre de type de colonnes. Ces types peuvent être        |
|    |regroupés en trois catégories : les types numériques, les types date et heure, et les |
|    |types chaînes de caractères. Ce paragraphe présente les différents types disponibles  |
|    |et leur tailles respectives, puis il détaille les caractéristiques de chaque          |
|    |catégorie. La présentation des types est intentionnellement brèves : les descriptions |
|    |détaillées fourniront toutes les informations nécessaires pour un type particulier,   |
|    |comme par exemple les formats autorisés pour chaque colonne.                          |
|    |•  Voici la liste des types de colonnes utilisés par MySQL. Les codes suivants sont   |
|    |utilisé durant les descriptions :                                                     |
|    |•  M Indique la taille maximale d'affichage. La taille maximale autorisée par défaut  |
|    |est 255.                                                                              |
|    |•  D S'applique aux types à virgule flottante, et précise le nombre de chiffre après  |
|    |la virgule.                                                                           |
|    |Crochets (``['' et ``]'') indique que cet argument est optionnel.                     |
|    |NB : Il est toujours possible de spécifier ZEROFILL pour une colonne. MySQL ajoutera  |
|    |alors automatiquement l'attribut UNSIGNED à la colonne.                               |
|    |•  TINYINT[(M)] [UNSIGNED] [ZEROFILL] Un très petit entier. Signé, il couvre          |
|    |l'intervalle -128 à 127 ; non signé, il couvre 0 à 255.                               |
|    |•  SMALLINT[(M)] [UNSIGNED] [ZEROFILL] Un petit entier. Signé, il couvre l'intervalle |
|    |-32768 à 32767; non signé, il couvre 0 à 65535.                                       |
|    |•  MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] Un entier de taille intermédiaire. Signé, il  |
|    |couvre l'intervalle -8388608 à 8388607; non signé, il couvre 0 à 16777215.            |
|    |•  INT[(M)] [UNSIGNED] [ZEROFILL] Un entier de taille normale. Signé, il couvre       |
|    |l'intervalle -2147483648 à 2147483647; non signé, il couvre 0 à 4294967295.           |
|    |•  INTEGER[(M)] [UNSIGNED] [ZEROFILL] Un synonyme pour INT.                           |
|    |•  BIGINT[(M)] [UNSIGNED] [ZEROFILL] Un entier de grande taille. Signé, il couvre     |
|    |l'intervalle -9223372036854775808 à 9223372036854775807; non signé, il couvre 0 à     |
|    |18446744073709551615. NB : toutes les opérations arithmétiques effectuée en interne,  |
|    |utilise des BIGINT signés ou DOUBLE , donc il ne faut pas utiliser les grands entiers |
|    |non signé au delà de 9223372036854775807 (63 bits), hormis pour les fonctions sur les |
|    |bits. NB : les opérations -, + et * utiliseront des BIGINT , même lorsque les         |
|    |arguments seront des entiers. Cela signifie que la multiplication de deux grands      |
|    |entiers (ou le résultat de fonction qui retourne des entiers) peut avoir des résultats|
|    |surprenants, si le résultat est supérieur à 9223372036854775807                       |
|    |•  FLOAT(precision) [ZEROFILL] Un nombre à virgule flottante. Il est obligatoirement  |
|    |signé. precision peut prendre les valeurs de 4 ou 8. FLOAT(8) est un nombre à         |
|    |précision double. Ces types sont identiques aux types FLOAT et DOUBLE décrit          |
|    |ci-dessous, mais leur précision peut être paramétrée. Avec MySQL 3.23, ce sont de     |
|    |vrais nombres à virgule flottante, alors qu'avec les anciennes versions,              |
|    |FLOAT(precision) n'avait que 2 décimales. Cette syntaxe a été ajoutée pour assurer la |
|    |compatibilité ODBC.                                                                   |
|    |•  FLOAT[(M,D)] [ZEROFILL] Un nombre à virgule flottante, en précision simple. Il est |
|    |toujours signé. Les valeurs sont comprises -3.402823466E+38 et -1.175494351E-38.      |
|    |•  DOUBLE[(M,D)] [ZEROFILL] Un nombre à virgule flottante, en précision double. Il est|
|    |toujours signé. Les valeurs sont comprises -1.7976931348623157E+308 et                |
|    |2.2250738585072014E-308.                                                              |
|    |•  DOUBLE PRECISION[(M,D)] [ZEROFILL]                                                 |
|    |•  REAL[(M,D)] [ZEROFILL] Des synonymes pour DOUBLE.                                  |
|    |•  DECIMAL(M,D) [ZEROFILL] Un nombre à virgule flottante. Il est toujours signé. Il se|
|    |comporte comme une colonne CHAR . Il n'est pas paqué, c'est à dire que le nombre est  |
|    |stocké comme une chaîne de chiffre. Chaque chiffre, le signe moins, la virgule occupe |
|    |un caractère. Si D vaut 0, le nombre n'aura pas de décimales, ni de virgule. La taille|
|    |maximale pour les décimales est la même que pour les DOUBLE , mais en il peut être    |
|    |limité par le choix de of M et D. Avec MySQL 3.23, M n'inclut plus le signe           |
|    |moins``-'', ni la virgule des nombres décimaux (norme ANSI SQL.).                     |
|    |•  NUMERIC(M,D) [ZEROFILL] Un synonyme pour DECIMAL.                                  |
|    |•  DATE Une date. L'intervalle valide de date va de '1000-01-01' à '9999-12-31'. MySQL|
|    |affiche les DATE avec le format , mais il est possible d'affecter des DATE en         |
|    |utilisant indifféremment des chaînes ou des nombres.                                  |
|    |•  DATETIME Une combinaison de date et d'heure. L'intervalle valide va de '1000-01-01 |
|    |00:00:00' to '9999-12-31 23:59:59'. MySQL affiche DATETIME avec le format 'YYYY-MM-DD |
|    |HH:MM:SS', mais il est possible d'affecter des DATETIME en utilisant indifféremment   |
|    |des chaînes ou des nombres.                                                           |
|    |•  TIMESTAMP[(M)] Un timestamp : la date et l'heure, exprimée en secondes, depuis le  |
|    |1er janviers 1970. Il permet de couvrir un intervalle allant de'1970-01-01 00:00:00' à|
|    |quelque part, durant l'année 2037. MySQL affiche les TIMESTAMP avec les format        |
|    |YYYYMMDDHHMMSS, YYMMDDHHMMSS, YYYYMMDD ou YYMMDD, suivant que M vaut 14 (ou absent),  |
|    |12, 8 ou 6, mais il est possible d'affecter des TIMESTAMP en utilisant indifféremment |
|    |des chaînes ou des nombres. Une colonne de type TIMESTAMP est très pratique pour      |
|    |enregistrer des dates et heures lors d'un INSERT ou UPDATE, car cette colonne sera    |
|    |automatiquement mis à la date et heure de l'opération la plus récente, si aucune      |
|    |valeur n'est précisée. Il est aussi possible d'affecter l'heure courante en assignant |
|    |la valeur NULL à une colonne de type . ( 7.2.6 Types date et heure)                   |
|    |•  TIME Une mesure de l'heure. L'intervalle valide est '-838:59:59' à '838:59:59'.    |
|    |MySQL affiche TIME au format 'HH:MM:SS', mais il est possible d'affecter des TIME en  |
|    |utilisant indifféremment des chaînes ou des nombres.                                  |
|    |•  YEAR Un an. L'intervalle valide est 1901 à 2155, et 0000. MySQL affiche YEAR au    |
|    |format YYYY, mais il est possible d'affecter des YEAR en utilisant indifféremment des |
|    |chaînes ou des nombres}(Le type YEAR est nouveau en MySQL 3.22.)                      |
|    |•  CHAR(M) [BINARY] Une chaîne de caractère de taille fixe, et toujours complétée à   |
|    |droite par des espaces. M va de 1 à 255 caractères. Les espaces supplémentaires sont  |
|    |supprimés lorsque la valeur est retournée dans une requête. Les tris et comparaisons  |
|    |effectués sur des valeurs de type CHAR sont insensibles à la casse, à moins que le mot|
|    |clé BINARY soit précisé.                                                              |
|    |•  VARCHAR(M) [BINARY] Une chaîne de caractère de longueur variable. Les espaces en   |
|    |fin de chaîne sont supprimés lorsque la chaîne est stockée (ce n'est pas conforme à la|
|    |norme ANSI SQL). Va de 1 a 255 caractères . Les tris et comparaisons effectués sur des|
|    |valeurs de type VARCHAR sont insensibles à la casse, à moins que le mot clé BINARY    |
|    |soit précisé. Voir aussi la section 7.6.1 Modifications automatiques de type de       |
|    |colonne.                                                                              |
|    |•  TINYBLOB                                                                           |
|    |•  TINYTEXT Un objet BLOB ou TEXT avec une longueur maximale de 255 (2^8 - 1). Voir   |
|    |aussi la section 7.6.1 Modifications automatiques de type de colonne.                 |
|    |•  BLOB                                                                               |
|    |•  TEXT Un objet BLOB ou TEXT avec une longueur maximale de 65535 (2^16 - 1). 7.6.1   |
|    |Modifications automatiques de type de colonne.                                        |
|    |•  MEDIUMBLOB                                                                         |
|    |•  MEDIUMTEXT Un objet BLOB ou TEXT avec une longueur maximale de 16777215 (2^24 - 1).|
|    |7.6.1 Modifications automatiques de type de colonne.                                  |
|    |•  LONGBLOB                                                                           |
|    |•  LONGTEXT Un objet BLOB ou TEXT avec une longueur maximale de 4294967295 (2^32 - 1).|
|    |7.6.1 Modifications automatiques de type de colonne.                                  |
|    |•  ENUM('value1','value2',...) Une énumération. Un objet chaîne peut prendre une des  |
|    |valeurs contenue dans une liste de valeur 'value1', 'value2', ..., ou NULL . Une ENUM |
|    |peut avoir un maximum de 65535 valeurs distinctes.                                    |
|    |•  SET('value1','value2',...) Un ensemble. Un objet chaîne peut prendre une ou        |
|    |plusieurs valeurs, chacun de ces valeur devant être contenue dans une liste de valeurs|
|    |'value1', 'value2', .... Un SET peut prendre jusqu'à 64 éléments.                     |
|    |7.2.1 Tailles nécessaires pour le stockage de types de colonnes                       |
|    |Voici la liste des espaces mémoire requis, par type.                                  |
|    |7.2.2 Types numériques                                                                |
|    |Column type                                                                           |
|    |Storage required                                                                      |
|    |                                                                                      |
|    |TINYINT                                                                               |
|    |1 byte                                                                                |
|    |                                                                                      |
|    |SMALLINT                                                                              |
|    |2 bytes                                                                               |
|    |                                                                                      |
|    |MEDIUMINT                                                                             |
|    |3 bytes                                                                               |
|    |                                                                                      |
|    |INT                                                                                   |
|    |4 bytes                                                                               |
|    |                                                                                      |
|    |INTEGER                                                                               |
|    |4 bytes                                                                               |
|    |                                                                                      |
|    |BIGINT                                                                                |
|    |8 bytes                                                                               |
|    |                                                                                      |
|    |FLOAT(4)                                                                              |
|    |4 bytes                                                                               |
|    |                                                                                      |
|    |FLOAT(8)                                                                              |
|    |8 bytes                                                                               |
|    |                                                                                      |
|    |FLOAT                                                                                 |
|    |4 bytes                                                                               |
|    |                                                                                      |
|    |DOUBLE                                                                                |
|    |8 bytes                                                                               |
|    |                                                                                      |
|    |DOUBLE PRECISION                                                                      |
|    |8 bytes                                                                               |
|    |                                                                                      |
|    |REAL                                                                                  |
|    |8 bytes                                                                               |
|    |                                                                                      |
|    |DECIMAL(M,D)                                                                          |
|    |M bytes (D+2, if M < D)                                                               |
|    |                                                                                      |
|    |NUMERIC(M,D)                                                                          |
|    |M bytes (D+2, if M < D)                                                               |
|    |                                                                                      |
|    |7.2.3 Types date et heure                                                             |
|    |Column type                                                                           |
|    |Storage required                                                                      |
|    |                                                                                      |
|    |DATETIME                                                                              |
|    |8 bytes                                                                               |
|    |                                                                                      |
|    |DATE                                                                                  |
|    |3 bytes                                                                               |
|    |                                                                                      |
|    |TIMESTAMP                                                                             |
|    |4 bytes                                                                               |
|    |                                                                                      |
|    |TIME                                                                                  |
|    |3 bytes                                                                               |
|    |                                                                                      |
|    |YEAR                                                                                  |
|    |1 byte                                                                                |
|    |                                                                                      |
|    |7.2.4 Types chaîne                                                                    |
|    |Column type                                                                           |
|    |taille requise                                                                        |
|    |                                                                                      |
|    |CHAR(M)                                                                               |
|    |M octets, 1 <= M <= 255                                                               |
|    |                                                                                      |
|    |VARCHAR(M)                                                                            |
|    |L+1 bytes, avec L <= M et 1 <= M <= 255                                               |
|    |                                                                                      |
|    |TINYBLOB, TINYTEXT                                                                    |
|    |L+1 octets, where L < 2^8                                                             |
|    |                                                                                      |
|    |BLOB, TEXT                                                                            |
|    |L+2 octets, where L < 2^16                                                            |
|    |                                                                                      |
|    |MEDIUMBLOB, MEDIUMTEXT                                                                |
|    |L+3 octets, where L < 2^24                                                            |
|    |                                                                                      |
|    |LONGBLOB, LONGTEXT                                                                    |
|    |L+4 octets, where L < 2^32                                                            |
|    |                                                                                      |
|    |ENUM('value1','value2',...)                                                           |
|    |1 ou 2 octets, suivant le nombre de valeur dans l'énumeration (65535 au maximum)      |
|    |                                                                                      |
|    |SET('value1','value2',...)                                                            |
|    |1, 2, 3, 4 ou 8 octets, suivant le nombre de membre de l'ensemble (64 membres au      |
|    |maximum)                                                                              |
|    |                                                                                      |
|    |Les types VARCHAR, BLOB et TEXT sont des types à longueur variable, dont taille de    |
|    |stockage dépend plus de la valeur qui leur est assignée que de leur taille maximale.  |
|    |Par exemple, une colonne de type VARCHAR(10) peut contenir une chaîne de 10 caractères|
|    |aux maximum. La taille réelle nécessaire est la longueur de la chaîne, plus 1 octet,  |
|    |qui stockera la taille réelle de la chaîne. Par exemple, la chaîne 'abcd' occupe 5    |
|    |octets.                                                                               |
|    |Les types BLOB et TEXT ont besoin de 1, 2, 3 ou 4 octets pour stocker la taille de la |
|    |colonne, en fonction du type.                                                         |
|    |Si une table possède au moins une colonne de longueur variable, l'enregistrement sera |
|    |aussi de longueur variable. Il faut noter que lorsqu'une table est créée, MySQL peut, |
|    |sous certaines conditions, changer le type d'une colonne de longueur variable en un   |
|    |type de colonne de longueur fixe, et vice-versa. Pour plus de détails, 7.6.1          |
|    |Modifications automatiques de type de colonne.                                        |
|    |La taille d'un objet ENUM est déterminé par le nombre d'énumération différentes. 1    |
|    |octet est suffisant pour décrire une énumération qui a jusqu'à 255 valeurs différentes|
|    |; 2 octets sont nécessaires décrire une énumération qui aurait jusqu'                 |
|    |La taille d'un objet SET est déterminé par le nombre d'élément distinct qu'il         |
|    |contient. Si la taille d'un SET est N, le SET occupera (N+7)/8 octets, arrondi aux    |
|    |entiers 1,2,3,4, ou 8 octets. Un ensemble peut contenir jusqu'à 64 éléments.          |
|    |7.2.5 Types numériques                                                                |
|    |Tous les types entiers disposent d'un attribut optionnel UNSIGNED. Les valeurs non    |
|    |signées sont utilisées quand les nombres utilisé sont uniquement positifs, ou bien    |
|    |lorsqu'il faut pouvoir manipuler des nombres un peu plus grand de normalement.        |
|    |Tous les types numériques disposent d'un attribut optionnel ZEROFILL. Cette option    |
|    |force l'affichage de tous les zéros non significatifs. Ainsi, dans une colonne de type|
|    |INT(5) ZEROFILL, 4 sera affiché : 00004.                                              |
|    |Quand une valeur trop grande est affectée à une colonne, MySQL limitera cette valeur  |
|    |au maximum qu'il peut stocker dans la colonne.                                        |
|    |Par exemple, soit une colonne de type INT qui accueille des nombres dans l'intervalle |
|    |-2147483648 to 2147483647. Lorsqu'on tente d'inserer -9999999999 dans cette colonne,  |
|    |MySQL utilisera automatiquement la plus petite valeur possible, soit -2147483648 . De |
|    |même, Lorsqu'on tente d'inserer 9999999999 dans cette colonne, MySQL utilisera        |
|    |automatiquement la plus grande valeur possible, soit 2147483647.                      |
|    |Si une colonne est de type INT UNSIGNED, la taille de la colonne est la même, mais les|
|    |extrémités sont différentes. Lors d'une tentative d'insertion, -9999999999 et         |
|    |9999999999 deviendront respectivement 0 et 4294967296.                                |
|    |Ces conversions implicites sont signalées comme des alertes (``warnings''), lors des  |
|    |requêtes incluant ALTER TABLE, LOAD DATA INFILE, UPDATE et INSERT multi-lignes.       |
|    |La taille maximale (M) et le nombre de décimales (D) sont utilisées lors du formatage |
|    |et des calculs de la taille maximale d'une colonne.                                   |
|    |MySQL tentera d'enregistrer n'importe quelle valeur, du moment que cette dernière peut|
|    |être contenue dans la colonne, et malgré le dépassement de limite d'affichage. Par    |
|    |exemple, une colonne de type INT(4) peut afficher 4 caractères. Il est cependant      |
|    |possible d'insérer une valeur qui a plus que 4 chiffres, telle que 12345. La taille   |
|    |d'affichage est dépassée, mais 12345 est bien dans l'intervalle autorisé pour un INT. |
|    |Donc, MySQL va enregistrer la valeur de 12345 . Lors d'une requête, MySQL retournera  |
|    |bien la vraie valeur, c'est à dire . 12345                                            |
|    |Le type DECIMAL peut être considéré comme un type numérique (puisqu'il est synonyme de|
|    |NUMERIC ), mais ce type est en fait enregistré comme une chaîne. Un caractère est     |
|    |utilisé pour chaque chiffre, pour la virgule et pour le signe moins``-''. Si D vaut 0,|
|    |DECIMAL et NUMERIC ne contiennent ni virgule, ni partie décimale.                     |
|    |La taille maximale d'une valeur DECIMAL est la même que celle d'un DOUBLE, mais elle  |
|    |peut dépendre des choix de M et D. Par exemple, un DECIMAL déclaré tel que indique    |
|    |DECIMAL(4,2) que la valeur maximale aura 2 chiffres après la virgule. Etant donné la  |
|    |façon avec laquelle le type DECIMAL est enregistré, ce DECIMAL sera compris entre-.99 |
|    |to 9.99, ce qui est nettement moins que les valeurs accessibles avec un DOUBLE.       |
|    |Pour éviter certains problèmes d'arrondissement, MySQL ajuste toujours les valeurs    |
|    |qu'il enregistre au nombre de décimale de la colonne. Ainsi, pour une colonne de type |
|    |FLOAT(8,2)., le nombre de décimale est 2. Donc, un nombre tel que 2.333 sera arrondi à|
|    |2.33, puis enregistré.                                                                |
|    |7.2.6 Types date et heure                                                             |
|    |Les types date et heure sont DATETIME, DATE, TIMESTAMP, TIME et YEAR. Chacun dispose  |
|    |d'un intervalle de validité, et une valeur ``zéro'', qui peut être utilisé pour       |
|    |indiquer une valeur illégale.                                                         |
|    |Voici quelques considérations générales à garder à l'esprit quand on travaille avec   |
|    |les types date et heure :                                                             |
|    |MySQL retourne les valeurs de date et d'heure dans un format standard unique, mais il |
|    |est capable d'interpréter un grand nombre de format d'entrée. Néanmoins, seuls les    |
|    |formats décrit dans les sections suivantes sont supportés. MySQL attends des dates    |
|    |valides, et des effets imprévisibles peuvent résulter de l'utilisation d'autres       |
|    |formats.                                                                              |
|    |Bien que MySQL tente d'interpréter un grand nombre de format de date, l'année devra   |
|    |toujours être placée à gauche. Les dates doivent être données dans l'ordre            |
|    |année-mois-jour (ie : '98-09-04'), plutôt que dans l'ordre mois-jour-année ou l'ordre |
|    |jour-mois-année utilisés habituellement. (ie '09-04-98', '04-09-98').                 |
|    |MySQL convertit automatiquement une date ou une heure en un nombre, si cette valeur   |
|    |est utilisé dans un contexte numérique, et vice-versa.                                |
|    |Quand MySQL rencontre une valeur pour une date ou une heure qui n'est pas valide, il  |
|    |la convertit en valeur ``zéro''. Les problèmes de dépassement de capacités sont réglés|
|    |comme pour les types numériques, en ramenant la valeur au maximum ou au minimum de    |
|    |l'intervalle autorisé. La table suivante montre les formats des valeurs ``zéro''.     |
|    |Column type                                                                           |
|    |``Zero'' value                                                                        |
|    |                                                                                      |
|    |DATETIME                                                                              |
|    |'0000-00-00 00:00:00'                                                                 |
|    |                                                                                      |
|    |DATE                                                                                  |
|    |'0000-00-00'                                                                          |
|    |                                                                                      |
|    |TIMESTAMP                                                                             |
|    |00000000000000 (length depends on display size)                                       |
|    |                                                                                      |
|    |TIME                                                                                  |
|    |'00:00:00'                                                                            |
|    |                                                                                      |
|    |YEAR                                                                                  |
|    |0000                                                                                  |
|    |                                                                                      |
|    |Les valeurs ``zéro'' sont des valeurs particulières, mais il est parfaitement possible|
|    |de les utiliser pour les enregistrer ou y faire référence. Il est aussi possible de   |
|    |les écrire '0' ou 0,qui sont plus facile à écrire.                                    |
|    |Les dates ``Zéro'' utilisées via MyODBC sont automatiquement converties à NULL par    |
|    |MyODBC 2.50.12 et mieux, car ODBC ne peut pas manipuler de telle valeur.              |
|    |7.2.6.1 Bug de l'an 2000 et données de types date                                     |
|    |Les types DATETIME, DATE et TIMESTAMP sont proches. Cette section décrit leur         |
|    |caractéristiques, et montre en quoi ils sont similaires, et en quoi ils sont          |
|    |différents.                                                                           |
|    |Le type DATETIME est utile pour manipuler en même temps une date et une heure. . MySQL|
|    |retourne et affiche les valeurs de type DATETIME au format 'YYYY-MM-DD HH:MM:SS'.     |
|    |L'intervalle valide pour le type DATETIME est '1000-01-01 00:00:00' à '9999-12-31     |
|    |23:59:59'. (``valide`` signifie que des valeurs anciennes pourrait fonctionner, mais  |
|    |qu'il n'y a aucune garantie).                                                         |
|    |Le type DATE est utilisé pour manipuler simplement une date, sans l'heure. MySQL      |
|    |retourne et affiche les valeurs de type DATE au format 'YYYY-MM-DD' L'intervalle      |
|    |valide pour le type DATE est '1000-01-01' à '9999-12-31'                              |
|    |Le type TIMESTAMP est utilisé automatiquement lors de requête , avec la valeur        |
|    |courante de date et d'heure. Si il y a plusieurs colonnes de type TIMESTAMP , seule la|
|    |première sera automatiquement mise à jour.                                            |
|    |La datation automatique intervient sur la première colonne de type TIMESTAMP , et dans|
|    |les conditions suivantes :                                                            |
|    |La colonne n'est pas expressément nommée dans la requête INSERT ou LOAD DATA          |
|    |La colonne n'est pas expressément nommée dans une requête , et au moins une autre     |
|    |colonne change UPDATE de valeur (Il est important de noter qu'une requête UPDATE qui  |
|    |affecterait la même valeur que celle qui est déjà affectée dans la colonne, alors la  |
|    |colonne TIMESTAMP ne sera pas mise à jour, car MySQL va ignorer la requête, par souci |
|    |d'efficacité.)                                                                        |
|    |La colonne TIMESTAMP est explicitement mise à NULL.                                   |
|    |Dans le cas o√π il y a plusieurs colonnes de type TIMESTAMP, il est possible d'affecter|
|    |la valeur courante de date et d'heure, en affectant la valeur NULL ou NOW().          |
|    |Il est possible d'affecter n'importe quelle date à une colonne de type TIMESTAMP, en  |
|    |lui affectant explicitement la valeur désirée. Cela est vrai pour toutes les colonnes |
|    |de type TIMESTAMP, y compris la première. Par exemple, il est possible d'utiliser une |
|    |colonne de type pour enregistrer le moment de création de la ligne, mais qui ne sera  |
|    |plus changé par la suite.:                                                            |
|    |Il suffit de laisser MySQL affecter la valeur automatiquement lors de la création de  |
|    |la ligne. L'initalisation sera faite au jour et heure courante.                       |
|    |Lors des modifications ultérieurs, il suffit d'affecter à la colonne sa propre valeur.|
|    |                                                                                      |
|    |Ou alors, il est aussi simple d'utiliser une colonne de type DATETIME, qui sera       |
|    |initialisé à l'aide de la commande NOW() , et qui ne sera plus jamais modifiée.       |
|    |TIMESTAMP couvre un espace de temps qui commence en 1970 et se termine quelques par en|
|    |2037, avec un précision d'une seconde. Ses valeurs sont affichée comme des nombres.   |
|    |Le format utilisé par pour retourner les valeurs de type dépendent de la taille de    |
|    |l'affichage, comme présenté ci dessous. Un complet affiche 14 chiffres, mais il est   |
|    |possible de n'afficher qu'une partie.                                                 |
|    |Column type                                                                           |
|    |Display format                                                                        |
|    |                                                                                      |
|    |TIMESTAMP(14)                                                                         |
|    |YYYYMMDDHHMMSS                                                                        |
|    |                                                                                      |
|    |TIMESTAMP(12)                                                                         |
|    |YYMMDDHHMMSS                                                                          |
|    |                                                                                      |
|    |TIMESTAMP(10)                                                                         |
|    |YYMMDDHHMM                                                                            |
|    |                                                                                      |
|    |TIMESTAMP(8)                                                                          |
|    |YYYYMMDD                                                                              |
|    |                                                                                      |
|    |TIMESTAMP(6)                                                                          |
|    |YYMMDD                                                                                |
|    |                                                                                      |
|    |TIMESTAMP(4)                                                                          |
|    |YYMM                                                                                  |
|    |                                                                                      |
|    |TIMESTAMP(2)                                                                          |
|    |YY                                                                                    |
|    |                                                                                      |
|    |Toutes les colonnes de type ont besoin de la même quantité de mémoire, quelque soit le|
|    |format d'affichage. Les formats d'affichage les plus courants sont le 6, le 8, le 12  |
|    |et le 14. Il est possible d'imposer une taille arbitraire au format d'affichage au    |
|    |moment de la création de la table, mais 0 et toutes les valeurs supérieures à 14      |
|    |seront ramenées à 14. Les valeurs impaires entre 1 et 13 sont arrondies au nombre     |
|    |entier pair supérieur.                                                                |
|    |Il est possible d'affecter des valeurs de type DATETIME, DATE et TIMESTAMP en         |
|    |utilisant n'importe lequel des formats suivants :                                     |
|    |Une chaîne, avec le format 'YYYY-MM-DD HH:MM:SS' ou 'YY-MM-DD HH:MM:SS'. Les '-' et ' |
|    |:' ne sont pas obligatoires, et n'importe quel caractère non numérique. Par exemple,  |
|    |'98-12-31 11:30:45', '98.12.31 11+30+45', '98/12/31 11*30*45' et '98@12@31 11^30^45'  |
|    |sont équivalents.                                                                     |
|    |Une chaîne, avec le format 'YYYY-MM-DD' ou 'YY-MM-DD'. Les '-' et ' :' ne sont pas    |
|    |obligatoires, et ils peuvent être remplacé par quel caractère non numérique. Par      |
|    |exemple, '98-12-31', '98.12.31', '98/12/31' et '98@12@31' sont équivalents.           |
|    |Une chaîne sans aucun délimiteur, avec le format 'YYYYMMDDHHMMSS' ou 'YYMMDDHHMMSS',  |
|    |en supposant que cette chaîne a bien un sens en tant que date. Par exemple,           |
|    |'19970523091528' et '970523091528 seront comprises comme '1997-05-23 09:15:28'.Au     |
|    |contraire, '971122459015' n'est pas valide (le nombre de seconde n'est pas valide), et|
|    |sera remplacé par : '0000-00-00 00:00:00'.                                            |
|    |Une chaîne sans aucun délimiteur, avec le format 'YYYYMMDD' or 'YYMMDD', en supposant |
|    |que cette chaîne a bien un sens en tant que date. Par exemple, '19970523' et '970523' |
|    |seront comprises comme '1997-05-23'.Au contraire, '971332' n'est pas valide (le nombre|
|    |de mois et de jour ne sont pas valides), et sera remplacé par : '0000-00-00'.         |
|    |Un nombre avec le format YYYYMMDDHHMMSS or YYMMDDHHMMSS, en supposant que cette chaîne|
|    |a bien un sens en tant que date. Par exemple, 19830905132800 et 830905132800 seront   |
|    |comprises comme '1983-09-05 13:28:00'                                                 |
|    |Un nombre avec le format YYYYMMDD or YYMMDD, en supposant que cette chaîne a bien un  |
|    |sens en tant que date. Par exemple, 19830905132800 et 830905132800 seront comprises   |
|    |comme '1983-09-05 13:28:00'                                                           |
|    |Le résultat d'une fonction qui retourne une valeur acceptable en dans un contexte de  |
|    |DATETIME, DATE or TIMESTAMP, comme NOW() or CURRENT_DATE.                             |
|    |Toutes les valeurs de type DATETIME, DATE ou TIMESTAMP sont converties automatiquement|
|    |en ``zero'' du même type ('0000-00-00 00:00:00', '0000-00-00' ou 00000000000000).     |
|    |Pour les valeurs spécifiées au format chaîne avec des délimiteurs, il n'est pas       |
|    |nécessaire de préciser les deux chiffres pour les mois ou les jours. Par exemple,     |
|    |'1979-6-9' et '1979-06-09' sont identiques. De la même façon, pour les valeurs        |
|    |spécifiées au format chaîne avec des délimiteurs, il n'est pas nécessaire de préciser |
|    |les deux chiffres pour les heures, minutes ou secondes. Ainsi, '1979-10-30 1:2:3' et  |
|    |'1979-10-30 01:02:03' sont identiques.                                                |
|    |Les valeurs spécifiée au format nombre doivent avoir 6, 8, 12 ou 14 chiffres. Si le   |
|    |nombre a 8 ou 14 chiffres, MySQL utilisera respectivement le format YYYYMMDD ou       |
|    |YYYYMMDDHHMMSS, où l'année sera représentée par les quatre premiers chiffres. Si le   |
|    |nombre a 6 ou 12 chiffres, MySQL utilisera respectivement le format YYMMDD or         |
|    |YYMMDDHHMMSS, où l'année sera représentée par les deux premiers chiffres. Si le nombre|
|    |n'a pas le bon nombre de chiffre, il sera complété avec des zéros non significatif    |
|    |(placés avant le premier chiffre), jusqu'à correspondre à une taille analysable.      |
|    |Les valeurs non délimitées, sont interprétées en fonction de leur longueur. Si la     |
|    |chaîne fait 8 ou 14 caractères, l'année sera considérée comme ayant 4 chiffres. Sinon,|
|    |l'année n'aura que les deux premiers chiffres. La chaîne est interprétée de gauche à  |
|    |droite, en lisant successivement l'année, le mois, le jour, l'heure, la minute et la  |
|    |seconde, dans la mesure où la chaîne est suffisamment longue. Cela implique qu'il ne  |
|    |faut pas utiliser de chaîne de moins de 6 caractères. Par exemple, la chaîne '9903',  |
|    |qui pourrait s'interpréter mars 1999, sera remplacée par la date ``zéro''. En effet,  |
|    |est capable de trouver l'année (99) et le mois (03) mais pas le jour (00), et donc    |
|    |cette valeur n'est pas valide.                                                        |
|    |Les colonnes de type TIMESTAMP enregistre les dates avec la précision maximum, quelque|
|    |soit la taille d'affichage. Cela a plusieurs implications :                           |
|    |Il faut toujours préciser l'année, le mois et le jour, même si le type de la colonne  |
|    |est TIMESTAMP(4) ou TIMESTAMP(2). Sinon, la valeur ne sera pas valide, et donc,       |
|    |remplacée par ``zéro''.                                                               |
|    |Si la structure de la table est modifié avec , pour agrandir la colonne, l'affichage  |
|    |présentera des données qui étaient précédemment cachées.                              |
|    |De la même façon, réduire la taille d'affichage d'une colonne TIMESTAMP ne causera pas|
|    |de perte d'information : elles seront simplement cachées.                             |
|    |Bien que les valeurs TIMESTAMP soient en précision maximale, la seul fonction qui     |
|    |opère directement sur la valeur enregistrée dans la base est UNIX_TIMESTAMP(). Les    |
|    |autres fonctions utilisent la valeur formatée. Cela signifie qu'il n'est pas possible |
|    |d'utiliser une fonction telle que HOUR() ou SECOND() à moins que la partie            |
|    |significative de TIMESTAMP soit inclus dans la valeur formatée. Par exemple, la partie|
|    |HH d'une valeur de type TIMESTAMP ne sera pas affichée, à moins que la taille de      |
|    |l'affichage soit au moins de 10. Ainsi, utiliser la fonction sur une valeur de type de|
|    |taille inférieure à 10 risque de retourner une valeur incohérente.                    |
|    |Il est possible d'affecter des valeurs de type date dans une variable d'un autre type |
|    |date. Cependant, cela peut engendrer des altérations ou des pertes d'informations. :  |
|    |Lors de l'affectation d'une DATE dans une variable de type DATETIME ou TIMESTAMP, la  |
|    |partie heure du résultat est mis à '00:00:00', car la valeur DATE ne contient aucune  |
|    |information d'heure.                                                                  |
|    |Lors de l'affectation d'une DATETIME ou TIMESTAMP dans une variable de type DATE, la  |
|    |partie heure du résultat est perdue , car la valeur DATE ne contient aucune           |
|    |information d'heure.                                                                  |
|    |Il ne faut pas confondre les différents formats de spécifications des DATETIME, DATE  |
|    |et TIMESTAMP . En effet, pour le même format d'acquisition, les différents types n'ont|
|    |pas le même intervalle de validité. Par exemple, TIMESTAMP ne peut contenir de valeur |
|    |antérieure à 1970 ou postérieure à 2037. Cela signifie qu'une date telle que as       |
|    |'1968-01-01', tout en étant valide pour les types DATETIME or DATE, n'est pas valide  |
|    |pour le type TIMESTAMP et sera transformée en 0, lors de l'affectation à un tel objet.|
|    |                                                                                      |
|    |Attention aussi aux erreurs de spécifications :                                       |
|    |En utilisant la forme de spécification avec délimiteurs, comme les délimiteurs ne sont|
|    |pas imposé, il est possible d'être induit en erreur par la forme : Ainsi, '10:11:12'  |
|    |ressemble à une heure, à cause des délimiteurs " : ". Mais, utilisé dans un contexte  |
|    |de date, il peut aussi être interprété comme la date'2010-11-12'. De même, la valeur  |
|    |'10:45:15' sera convertie en 0, car 45 ,'est pas un mois valide.                      |
|    |Les années spécifiées sur deux chiffres sont ambiguës :                               |
|    |Les années qui sont dans l'intervalle 00-69 sont considéré comme 2000-2069.           |
|    |Les années qui sont dans l'intervalle 70-99 sont considéré comme 1970-1999.           |
|    |7.2.6.2 Le type TIME                                                                  |
|    |MySQL retourne et affiche les valeurs de type TIME aux formats 'HH:MM:SS' ou          |
|    |'HHH:MM:SS'. Les valeurs de type TIME vont de '-838:59:59' à '838:59:59'. Le nombre   |
|    |d'heure peut être rendu aussi grand afin de pouvoir représenter les heures du jour,   |
|    |mais aussi de faire des calculs de différence d'heure entre deux jours, ce qui conduit|
|    |à des durée très supérieures à 24h, voire même des valeurs négatives.                 |
|    |Les valeurs de type TIME peuvent être définies de nombreuses manières différentes :   |
|    |Une chaîne de format 'HH:MM:SS'. Les :' ne sont pas obligatoires, et ils peuvent être |
|    |remplacé par n'importe quel caractère non numérique. Par exemple, , '10:11:12' et     |
|    |'10.11.12'sont équivalents..                                                          |
|    |Une chaîne sans délimiteurs, au format'HHMMSS', en supposant qu'elle est un sens en   |
|    |tant que date. Par exemple, '101112' sera interpreté comme '10:11:12', mais '109712'  |
|    |n'est pas valide et deviendra '00:00:00'.                                             |
|    |Un nombre au format HHMMSS, en supposant que cela ait un sens. Par exemple, 101112    |
|    |vaudra . '10:11:12'                                                                   |
|    |Le résultat d'une fonction qui retourne une valeur acceptable en dans un contexte de  |
|    |DATETIME, DATE or TIMESTAMP, comme NOW() or CURRENT_DATE.                             |
|    |Pour les valeurs de type TIME spécifiées au format chaîne avec des délimiteurs, il    |
|    |n'est pas nécessaire de préciser les deux chiffres pour les heures, minutes ou        |
|    |secondes. Ainsi, '8:3:2' et '08:03:02'.sont identiques.                               |
|    |Attention aux affections de valeurs courtes dans une colonne de type TIME. MySQL      |
|    |interprète les valeurs en supposant que les chiffres de gauche sont les secondes      |
|    |(MySQL interprète les valeurs de type TIME comme des intervalles de temps, plutôt     |
|    |qu'une date). Par exemple, '11:12', '1112' et 1112 pourraient être confondues avec    |
|    |'11:12:00' (12 minutes après 11 heures), mais MySQL le comprend comme '00:11:12' (11  |
|    |minutes, 12 seconds). De même, '12' et 12 representent '00:00:12'.                    |
|    |Toutes les valeurs de TIME, qui sont hors de l'intervalle de validité sont ramenées à |
|    |la valeur valide la plus proche. Ainsi, '-850:00:00' et '850:00:00' sont              |
|    |respectivement converties en'-838:59:59' et '838:59:59'.                              |
|    |Toutes les valeurs invalides de TIME sont converties en '00:00:00'. Il faut bien      |
|    |savoir que '00:00:00'est une valeur de TIME valide. Ainsi, si est stocké dans une     |
|    |table, il est impossible de dire si cela provient d'une erreur, ou si il a été affecté|
|    |à cette valeur.                                                                       |
|    |7.2.6.3 Le type YEAR                                                                  |
|    |Le type YEAR sert à représenter les années sur un octet.                              |
|    |MySQL retourne et affiche les YEAR au format YYYY: L'intervalle de validité est de    |
|    |1901 à 2155.                                                                          |
|    |Les valeurs de type YEAR peuvent être définies de nombreuses manières différentes :   |
|    |Une chaîne de 4 chiffres, dans l'intervalle de 1901 à 2155.                           |
|    |Un nombre de 4 chiffres, dans l'intervalle de 1901 à 2155.                            |
|    |Une chaîne de 2 chiffres, dans l'intervalle de '00' à '99'. Les valeurs de '00' à '69'|
|    |et de'70' à '99' seront converties en valeurs de type YEAR, dans les intervalles      |
|    |respectifs de 2000 à 2069 et de 1970 à 1999.                                          |
|    |Un nombre de 2 chiffres, dans l'intervalle de 1 à 99. Les valeurs de 1 à 69 et de70 à |
|    |99 seront converties en valeurs de type YEAR, dans les intervalles respectifs de 2000 |
|    |à 2069 et de 1970 à 1999. Il faut bien noter que ce format diffère légèrement du      |
|    |précédent, car il n'est pas possible de passer un nombre égal à 0, pour obtenir       |
|    |l'année 2000. Il faut spécifier une chaîne, '0' ou '00', sinon MySQL retournera 0000  |
|    |Le résultat d'une fonction qui retourne une valeur acceptable en dans un contexte de  |
|    |DATETIME, DATE or TIMESTAMP, comme NOW().                                             |
|    |Toutes les valeurs invalides de YEAR sont converties en 0000.                         |
|    |7.2.7 Types chaîne                                                                    |
|    |Les types chaînes sont CHAR, VARCHAR, BLOB, TEXT, ENUM et SET.                        |
|    |7.2.7.1 Les types CHAR et VARCHAR                                                     |
|    |Les types CHAR et VARCHAR sont similaires, mais ils diffèrent par la manière dont ils |
|    |sont stockés.                                                                         |
|    |Les valeurs de type CHAR sont de longueur fixée. La longueur est déclarée lors de la  |
|    |création de la table. Cette longueur peut aller de 1 à 255. Quand une valeur de type  |
|    |CHAR est enregistrée, elle est complétée à gauche par des espaces. Lorsque MySQL      |
|    |retourne cette valeur, ces espaces sont effacés.                                      |
|    |Les valeurs de type VARCHAR sont de longueur variable. Une longueur maximum est       |
|    |déclarée lors de la création de la table. Cette longueur peut aller de 1 à 255. Quand |
|    |une valeur de type CHAR est enregistrée, seul les caractères utiles sont enregistrés, |
|    |plus un octet pour enregistrer la taille de la chaîne. Les ne sont pas complétée à    |
|    |gauche par des espaces, mais les espaces en début de valeurs sont effacés lors de     |
|    |l'enregistrement (cette fonction d'effacement des espaces à l'enregistrement n'est pas|
|    |spécifiée dans ANSI SQL).                                                             |
|    |Lors de l'affectation d'une valeur de type CHAR ou VARCHAR dans une colonne trop      |
|    |petite, la valeur est tronquée à la taille de la colonne.                             |
|    |La table ci dessous illustre les différences de taille entre les deux types :         |
|    |Value                                                                                 |
|    |CHAR(4)                                                                               |
|    |Storage required                                                                      |
|    |VARCHAR(4)                                                                            |
|    |Storage required                                                                      |
|    |                                                                                      |
|    |''                                                                                    |
|    |' '                                                                                   |
|    |4 bytes                                                                               |
|    |''                                                                                    |
|    |1 byte                                                                                |
|    |                                                                                      |
|    |'ab'                                                                                  |
|    |'ab '                                                                                 |
|    |4 bytes                                                                               |
|    |'ab'                                                                                  |
|    |3 bytes                                                                               |
|    |                                                                                      |
|    |'abcd'                                                                                |
|    |'abcd'                                                                                |
|    |4 bytes                                                                               |
|    |'abcd'                                                                                |
|    |5 bytes                                                                               |
|    |                                                                                      |
|    |'abcdefgh'                                                                            |
|    |'abcd'                                                                                |
|    |4 bytes                                                                               |
|    |'abcd'                                                                                |
|    |5 bytes                                                                               |
|    |                                                                                      |
|    |Les valeurs retournées seront les mêmes, car dans tous les cas, les espaces situés en |
|    |début de chaîne seront effacées                                                       |
|    |Les valeurs de type CHAR et VARCHAR sont triées et comparées sans tenir compte de la  |
|    |casse, à moins que l'option BINARY ai été activée lors de la création de la table.    |
|    |Cette option signifie que cette colonne sera triée et comparée en tenant compte de la |
|    |casse, et en fonction de l'ordre de la table ASCII de la machine qui supporte MySQL.  |
|    |Le mode est contagieux : Cela signifie que si une colonne de type binaire est utilisée|
|    |dans une expression, la comparaison tiendra compte de la casse.                       |
|    |MySQL peut changer spontanément les types de colonne lors de la création d'une table..|
|    |7.6.1 Modifications automatiques de type de colonne.                                  |
|    |7.2.7.2 Les types BLOB et TEXT                                                        |
|    |Un BLOB est un binary long object, c'est à dire un objet binaire long, qui peut       |
|    |contenir une certaine quantité d'information. Les quatre types TINYBLOB, BLOB,        |
|    |MEDIUMBLOB et LONGBLOB ne diffèrent que par leur taille maximum. Voir 7.2.1 Tailles   |
|    |nécessaires pour le stockage de types de colonnes.                                    |
|    |Les quatre types TINYTEXT, TEXT, MEDIUMTEXT t LONGTEXT correspondent aux quatre types |
|    |BLOB et ont les mêmes tailles maximum, et les mêmes conditions de stockage. La seule  |
|    |différence entre les types BLOB et TEXT tient aux tris et aux comparaisons : les tris |
|    |et comparaisons tiennent compte de la casse, dans le cas des TEXT, et n'en tiennent   |
|    |pas compte, dans le cas des BLOB. En d'autres termes, un TEXT est un BLOB insensible à|
|    |la casse.                                                                             |
|    |Lors de l'affectation d'une valeur de type BLOB ou TEXT dans une colonne trop petite, |
|    |la valeur est tronquée à la taille de la colonne.                                     |
|    |En général, on peut considérer qu'une colonne de type TEXT est une colonne de type    |
|    |VARCHAR, aussi grande que désiré. De la même manière, on peut considérer qu'une       |
|    |colonne de type BLOB est une colonne de type VARCHAR BINARY, aussi grande que         |
|    |possible. Les différences sont :                                                      |
|    |Il est possible d'indexer les variables de type BLOB et TEXT pour les version de MySQL|
|    |3.23.2 ou plus récentes. Les anciennes versions ne le supporte pas.                   |
|    |Les espaces situés en début de chaîne ne sont pas effacés lors de l'enregistrement    |
|    |dans un BLOB t TEXT, contrairement aux colonnes de type VARCHAR. BLOB and TEXT columns|
|    |cannot have DEFAULT values.                                                           |
|    |Les valeurs de type BLOB t TEXT n'ont pas d'option DEFAULT.                           |
|    |MyODBC utilise le type LONGVARBINARY pour le type BLOB et LONGVARBINARY pour TEXT.    |
|    |Parce que les types peuvent être extrêmement grands, il y a certaines contraintes à   |
|    |leur utilisation :                                                                    |
|    |Pour utiliser la clause GROUP BY ou ORDER BY sur une colonne de type BLOB ou TEXT, il |
|    |faut commencer par convertir la colonne dans un type à longueur fixe. Pour cela, on   |
|    |utilise la fonction SUBSTRING. Par exemple :                                          |
|    |                                                                                      |
|    |mysql> SELECT commentaires FROM Nom_table , SUBSTRING(commentaires,20) as             |
|    |souschaîne ORDER BY souschaîne;                                                       |
|    |Si SUBSTRING n'est pas utilisé, le tri portera uniquement sur les max_sort_longueur   |
|    |premiers octets de la colonne. Par défaut, max_sort_longueur vaut 1024, et cette      |
|    |valeur peut être changée en utilisant l'option , lors du démarrage de MySQL. Il est   |
|    |possible d'utiliser la clause GROUP sur un BLOB or TEXT , en spécifiant la position de|
|    |la colonne, et en utilisant un alias. Par exemple :                                   |
|    |                                                                                      |
|    |mysql> select id,substring(blob_col,1,100) FROM Nom_table                             |
|    |GROUP BY 2;                                                                           |
|    |mysql> select id,substring(blob_col,1,100) as b FROM Nom_table                        |
|    |GROUP BY b;                                                                           |
|    |La taille maximale d'un objet de type est déterminée par son type, mais la quantité   |
|    |d'information qu'il est possible de transmettre entre le serveur et le client dépend  |
|    |de la quantité de mémoire vive et de la taille des buffers de communications. Il est  |
|    |possible de changer la taille des buffers, mais il faut le faire sur le serveur et sur|
|    |le client.                                                                            |
|    |Il faut bien noter que chaque valeur de type est représentée de manière interne par un|
|    |objet alloué. Contrairement aux autres objets, pour qui l'espace mémoire est réservé à|
|    |la création de la table.                                                              |
|    |7.2.7.3 Le type ENUM                                                                  |
|    |Le type est ENUM une chaîne, dont la valeur est choisi dans une liste de valeurs      |
|    |autorisées, et spécifiées à la création de la table.                                  |
|    |Cette valeur peut prendre les valeurs ("") ou NULL sous certaines conditions :        |
|    |Lors de l'insertion d'une valeur invalide dans un ENUM ( par exemple, une chaîne qui  |
|    |ne serait pas dans la liste des valeurs autorisées), une chaîne vide est insérée à la |
|    |place, afin d'indiquer une erreur.                                                    |
|    |Si une ENUM est déclarée NULL, NULL sera alors une valeur valide pour cette colonne,  |
|    |et la valeur par défaut sera aussi NULL. Si une ENUM est déclarée NOT NULL, la valeur |
|    |par défaut sera le premier élément de la liste de valeurs autorisées.                 |
|    |Chaque énumération a un index.                                                        |
|    |Les valeurs autorisées sont ordonnées et indexées à partir de 1.                      |
|    |L'index de la valeur erreur est 0. Cela signifie qu'il est possible d'utiliser la     |
|    |clause SELECT pour rechercher des lignes qui auraient une valeur ENUM invalide :      |
|    |                                                                                      |
|    |mysql> SELECT * FROM Nom_table WHERE enum_col=0;                                      |
|    |L'index de la valeur NULL est NULL.                                                   |
|    |Par exemple, une colonne de type ENUM("un", "deux", "trois") peut prendre chacune des |
|    |valeurs ci-dessous. L'index de la valeur est aussi indiqué.                           |
|    |Value                                                                                 |
|    |Index                                                                                 |
|    |                                                                                      |
|    |NULL                                                                                  |
|    |NULL                                                                                  |
|    |                                                                                      |
|    |""                                                                                    |
|    |0                                                                                     |
|    |                                                                                      |
|    |"one"                                                                                 |
|    |1                                                                                     |
|    |                                                                                      |
|    |"two"                                                                                 |
|    |2                                                                                     |
|    |                                                                                      |
|    |"three"                                                                               |
|    |3                                                                                     |
|    |                                                                                      |
|    |Une énumération peut avoir au maximum 65535 éléments.                                 |
|    |La casse des lettres est sans importance pour l'affection de valeur dans une colonne  |
|    |de type ENUM. Cependant, lorsque ces valeurs sont retournées, elles tiennent compte de|
|    |la casse des lettres tels qu'elle a été spécifiées à la création de la table.         |
|    |Lire une valeur de type ENUM dans un contexte numérique permet d'accèder à l'index de |
|    |la valeur. De même, lors de l'affectation d'un nombre dans une valeur ENUM, le nombre |
|    |sera traité comme un index, et la valeur enregistrée sera celle de l'énumération, à   |
|    |l'index précisé.                                                                      |
|    |Les valeurs d'une énumération sont triée en fonction de l'ordre dans lequel les       |
|    |éléments de l'énumération sont enregistrés lors de la création de la colonne (en      |
|    |d'autres termes, les valeurs d'une énumération sont triées en fonction de leur index).|
|    |Par exemple, "a" sera placé avant "b" pour ENUM("a", "b"), mais "b" sera placé avant  |
|    |"a" pour ENUM("b", "a").les chaînes vides sont placées avant les chaînes non vides, et|
|    |la valeur NULL passe avant toutes les autres.                                         |
|    |Pour visualiser toutes les valeurs d'une colonne de type, il faut utiliser SHOW       |
|    |COLUMNS FROM Nom_table LIKE Nom_col_enum et détailler les valeurs de la deuxième      |
|    |colonne.                                                                              |
|    |7.2.7.4 Le type SET                                                                   |
|    |Un ensemble est une chaîne qui peut avoir aucune, une ou plusieurs valeurs, chaque    |
|    |valeur étant choisie dans une liste de valeur autorisées lors de la création de la    |
|    |table. Les valeurs de type SET qui ont plusieurs valeurs sont spécifiées en séparant  |
|    |les membres par des virgules(``,'').. Par conséquent, les valeurs de type SET ne      |
|    |peuvent pas contenir de virgule.                                                      |
|    |Par exemple, une colonne de type SET("un", "deux") NOT NULL peut prendre les valeurs  |
|    |suivantes :                                                                           |
|    |                                                                                      |
|    |""                                                                                    |
|    |"un"                                                                                  |
|    |"deux"                                                                                |
|    |"un, deux"                                                                            |
|    |Un ensemble peut avoir un maximum de 64 membres distincts.                            |
|    |MySQL enregistre les valeurs de type SET values numériquement, avec le premier élément|
|    |situé au bit de poids faible. Lorsqu'une valeur de type SET est retournée dans un     |
|    |contexte numérique, les bits à 1 de cette valeurs correspondent à un membre du SET qui|
|    |appartienne à cette valeur. Si un nombre est enregistré dans une valeur de type SET,  |
|    |alors les bits mis à un de ce nombre détermineront les membres du SET qui             |
|    |appartiennent à la valeur. Par exemple, une colonne a été spécifiée par               |
|    |SET("a","b","c","d").Alors, les membres prennent la valeur suivante :                 |
|    |SET member                                                                            |
|    |Decimal value                                                                         |
|    |Binary value                                                                          |
|    |                                                                                      |
|    |a                                                                                     |
|    |1                                                                                     |
|    |0001                                                                                  |
|    |                                                                                      |
|    |b                                                                                     |
|    |2                                                                                     |
|    |0010                                                                                  |
|    |                                                                                      |
|    |c                                                                                     |
|    |4                                                                                     |
|    |0100                                                                                  |
|    |                                                                                      |
|    |d                                                                                     |
|    |8                                                                                     |
|    |1000                                                                                  |
|    |                                                                                      |
|    |Pour les valeurs qui contiennent plus d'un membre, l'ordre d'insertion n'importe pas. |
|    |Une valeur peut être insérée plusieurs fois, elle n'apparaîtra plus qu'une seule fois |
|    |dans le SET, et sera placé dans l'ordre des membres, à la création du SET. Par        |
|    |exemple, dans une colonne de type SET("a","b","c","d"), alors les valeurs "a, d", "d, |
|    |a" et "d,a,a,d,d" seront devenues "a, d", lorsqu'elle seront retournées par la base.  |
|    |Les valeurs de type s SET ont triées par ordre numérique. La valeur NULL est placée   |
|    |avant toutes les autres valeurs non- NULL.                                            |
|    |En général, il est possible d'utiliser la clause SELECT sur une colonne de type SET,  |
|    |en utilisant l'opérateur LIKE ou la fonction FIND_IN_SET().                           |
|    |                                                                                      |
|    |mysql> SELECT * FROM Nom_table WHERE Nom_col LIKE '%valeur%';                         |
|    |mysql> SELECT * FROM Nom_table WHERE FIND_IN_SET(valeur, Nom_col)>0;                  |
|    |Mais les exemples suivants sont aussi corrects                                        |
|    |                                                                                      |
|    |mysql> SELECT * FROM Nom_table WHERE Nom_col = 'val1,val2';                           |
|    |mysql> SELECT * FROM Nom_table WHERE Nom_col & 1;                                     |
|    |le premier exemple recherche une valeur exacte ('val1,val2'). Le second exemple       |
|    |recherche les valeurs qui contiennent le premier élément.                             |
|    |Pour visualiser toutes les valeurs d'une colonne de type, il faut utiliser SHOW       |
|    |COLUMNS FROM Nom_table LIKE Nom_col_enum et détailler les valeurs de la deuxième      |
|    |colonne.                                                                              |
|    |7.2.8 Choisir le bon type de colonne                                                  |
|    |Pour une utilisation aussi efficace de l'espace mémoire, il faut utiliser le type de  |
|    |colonne le plus précis possible. Par exemple, pour stocker un entier dont la valeur va|
|    |de 1 t 99999, MEDIUMINT UNSIGNED est le meilleur type.                                |
|    |La représentation des valeurs monétaires est un problème commun. Avec MySQL, le       |
|    |meilleur choix est le type DECIMAL. Il est enregistré comme une chaîne, ce qui        |
|    |n'entraîne aucune perte de données. Si la précision n'est pas primordiale, le type    |
|    |DOUBLE peut être un bon choix.                                                        |
|    |Pour une meilleure précision, il est toujours possible de convertir les nombres à     |
|    |virgule fixe en BIGINT. Cela autorise la manipulation d'entier pour les calculs, et il|
|    |suffit alors de les reconvertir en valeur à virgule flottante au moment de            |
|    |l'affichage. 10.17 Quel sont les différents formats de lignes? Quand utiliser         |
|    |VARCHAR/CHAR?.                                                                        |
|    |7.2.9 Index de colonne                                                                |
|    |Avec MySQL, tous les types de colonnes peuvent être indexés, à l'exception des types  |
|    |BLOB et TEXT. L'utilisation d'index est le meilleur moyen d'accélérer les performances|
|    |des clauses SELECT.                                                                   |
|    |Une table peut avoir jusqu'à 16 index. La taille maximale d'un index est de 256 bytes,|
|    |et cette valeur peut être choisie à la compilation de MySQL.                          |
|    |Il n'est pas possible d'indexer une colonne qui contient des valeurs NULL, donc une   |
|    |colonne indexée doit être déclarée NOT NULL.                                          |
|    |Pour les colonnes de type CHAR et VARCHAR, il est possible de préfixer la colonne.    |
|    |C'est un moyen beaucoup plus rapide et qui requiert moins d'espace disque qu'indexer  |
|    |une colonne complète. La syntaxe pour créer une telle colonne est la suivante :       |
|    |                                                                                      |
|    |KEY Nom_index(Nom_col(longueur))                                                      |
|    |L'exemple suivant créer un index pour les 10 premiers caractères de la colonne        |
|    |Nom_col.                                                                              |
|    |                                                                                      |
|    |mysql> CREATE TABLE test (                                                            |
|    |nom  CHAR(200) NOT NULL,                                                              |
|    |KEY Nom_index(nom(10)));                                                              |
|    |7.2.10 Index multi-colonnes                                                           |
|    |MySQL peut créer des indexes sur plusieurs colonnes en même temps. Un index peut      |
|    |contenir jusqu'à 15 colonnes (Avec les colonnes de type CHAR t VARCHAR , il est aussi |
|    |possible d'utiliser un préfixe lors de l'indexation).                                 |
|    |Un index de plusieurs colonnes peut être considéré comme un tableau trié contenant les|
|    |lignes obtenues en concaténant les valeurs des colonnes indexées.                     |
|    |MySQL gère les index sur plusieurs colonnes de manière à ce que les requêtes qui      |
|    |recherche une valeur connue dans la première colonne (avec une clause WHERE), soient  |
|    |rapides, même si les valeurs pour les autres colonnes ne sont pas précisées.          |
|    |Par exemple, soit la table suivante :                                                 |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> CREATE TABLE test (                                                            |
|    |id INT NOT NULL,                                                                      |
|    |nom CHAR(30) NOT NULL,                                                                |
|    |prenom CHAR(30) NOT NULL,                                                             |
|    |PRIMARY KEY (id),                                                                     |
|    |INDEX nom_complet (nom, prenom));                                                     |
|    |Ainsi, l'index nom_complet est un index sur les deux colonnes nom et prénom. L'index  |
|    |sera utilisé lors des requêtes qui recherchent un nom, ou un nom et un prénom. L'index|
|    |sera donc utilisé lors des requêtes suivantes :                                       |
|    |                                                                                      |
|    |mysql> SELECT * FROM test WHERE nom="Dupont";                                         |
|    |mysql> SELECT * FROM test WHERE nom ="Dupont"                                         |
|    |AND prenom="Michel";                                                                  |
|    |mysql> SELECT * FROM test WHERE nom ="Dupont"                                         |
|    |AND (prenom ="Michel" OR prenom ="Marie");                                            |
|    |mysql> SELECT * FROM test WHERE nom ="Dupont"                                         |
|    |AND prenom >="M" AND prenom < "N";                                                    |
|    |Cependant, l'index ne sera pas utilisé lors des requêtes suivantes :                  |
|    |                                                                                      |
|    |mysql> SELECT * FROM test WHERE prenom ="Michel";                                     |
|    |mysql> SELECT * FROM test WHERE nom="Dupont"                                          |
|    |OR prenom ="Michel";                                                                  |
|    |7.2.11 Utiliser des types de colonnes d'autres bases de données                       |
|    |Afin de simplifier le portage d'applications écrite en SQL sur d'autres base de       |
|    |données, MySQL remplace automatiquement les types présentés ci-dessous par les siens :|
|    |                                                                                      |
|    |Other vendor type                                                                     |
|    |MySQL type                                                                            |
|    |                                                                                      |
|    |BINARY(NUM)                                                                           |
|    |CHAR(NUM) BINARY                                                                      |
|    |                                                                                      |
|    |CHAR VARYING(NUM)                                                                     |
|    |VARCHAR(NUM)                                                                          |
|    |                                                                                      |
|    |FLOAT4                                                                                |
|    |FLOAT                                                                                 |
|    |                                                                                      |
|    |FLOAT8                                                                                |
|    |DOUBLE                                                                                |
|    |                                                                                      |
|    |INT1                                                                                  |
|    |TINYINT                                                                               |
|    |                                                                                      |
|    |INT2                                                                                  |
|    |SMALLINT                                                                              |
|    |                                                                                      |
|    |INT3                                                                                  |
|    |MEDIUMINT                                                                             |
|    |                                                                                      |
|    |INT4                                                                                  |
|    |INT                                                                                   |
|    |                                                                                      |
|    |INT8                                                                                  |
|    |BIGINT                                                                                |
|    |                                                                                      |
|    |LONG VARBINARY                                                                        |
|    |MEDIUMBLOB                                                                            |
|    |                                                                                      |
|    |LONG VARCHAR                                                                          |
|    |MEDIUMTEXT                                                                            |
|    |                                                                                      |
|    |MIDDLEINT                                                                             |
|    |MEDIUMINT                                                                             |
|    |                                                                                      |
|    |VARBINARY(NUM)                                                                        |
|    |VARCHAR(NUM) BINARY                                                                   |
|    |                                                                                      |
|    |Ce remplacement intervient à la création de la table. Après la création d'une table,  |
|    |les types retournés par une commande DESCRIBE Nom_table seront les types équivalent de|
|    |MySQL.                                                                                |
|    |7.3 Fonctions utilisées dans les clauses SELECT et WHERE                              |
|    |Une clause select ou where dans une command SQL peut contenir des expressions         |
|    |utilisant les fonctions décrites ci-dessous.                                          |
|    |Une expression qui contient une valeur aura toujours un résultat , sauf exceptions    |
|    |indiquées dans la documentation sur les opérateurs et fonctions.                      |
|    |Note: Il faut nécessairement un espace entre le nom de la fonction et la parenthèse   |
|    |ouvrante qui suit. Cela aide l'analyseur syntaxique de MySQL à faire la différence    |
|    |entre les appels de fonctions et les références aux tables ou colonnes qui            |
|    |interviennent dans la même colonne et qui ont le même nom que la fonction. Les espaces|
|    |autours des arguments aussi autorisés.                                                |
|    |Par souci de brièveté, les affichages d'exemples seront en mode réduit. Par exemple   |
|    |                                                                                      |
|    |mysql> select MOD(29,9);                                                              |
|    |1 rows in set (0.00 sec)                                                              |
|    |+-----------+                                                                         |
|    || mod(29,9) |                                                                         |
|    |+-----------+                                                                         |
|    ||         2 |                                                                         |
|    |+-----------+                                                                         |
|    |Sera affiché comme suit :                                                             |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select MOD(29,9);                                                              |
|    |-> 2                                                                                  |
|    |7.3.1 Fonction de groupement                                                          |
|    |( ... )                                                                               |
|    |( ... )                                                                               |
|    |Parenthèses. MySQL gère les priorités avec les parenthèses.                           |
|    |                                                                                      |
|    |mysql> select 1+2*3;                                                                  |
|    |-> 7                                                                                  |
|    |mysql> select (1+2)*3;                                                                |
|    |-> 9                                                                                  |
|    |Parentheses. Use these to force the order of evaluation in an expression.             |
|    |7.3.2 Opérations arithmétiques normales                                               |
|    |Les opérateurs arithmétiques usuels sont disponible. Il faut bien noter que dans le   |
|    |cas de -, + et *, le resultat est calculé avec la précision BIGINT (64-bit) si les    |
|    |deux opérateurs sont des entiers.                                                     |
|    |•  + Addition                                                                         |
|    |                                                                                      |
|    |mysql> select 3+5;                                                                    |
|    |-> 8                                                                                  |
|    |•  - Soustraction                                                                     |
|    |                                                                                      |
|    |mysql> select 3-5;                                                                    |
|    |-> -2                                                                                 |
|    |•  * Multiplication                                                                   |
|    |                                                                                      |
|    |mysql> select 3*5;                                                                    |
|    |-> 15                                                                                 |
|    |mysql> select 18014398509481984*18014398509481984.0;                                  |
|    |-> 324518553658426726783156020576256.0                                                |
|    |mysql> select 18014398509481984*18014398509481984;                                    |
|    |-> 0                                                                                  |
|    |Le résultat du dernier exemple est incorrect, car le résultat de la multiplication    |
|    |excède la taille maximale d'un BIGINT.                                                |
|    |•  / Division                                                                         |
|    |                                                                                      |
|    |mysql> select 3/5;                                                                    |
|    |-> 0.60                                                                               |
|    |La division par zéro retourne une valeur NULL:                                        |
|    |                                                                                      |
|    |mysql> select 102/(1-1);                                                              |
|    |-> NULL                                                                               |
|    |La division sera calculée avec l'arithmétique des BIGINT, uniquement dans le cas ou le|
|    |résultat doit être converti en entier !                                               |
|    |7.3.3 Fonctions sur les bits                                                          |
|    |MySQL utilise des BIGINT (64-bit) pour ses opérations sur les bits, donc tous les     |
|    |opérateurs suivants ont au portent au plus 64 bits.                                   |
|    |•  | OU bit à bit                                                                     |
|    |                                                                                      |
|    |mysql> select 29 | 15;                                                                |
|    |-> 31                                                                                 |
|    |•  & ET bit à bit                                                                     |
|    |                                                                                      |
|    |mysql> select 29 & 15;                                                                |
|    |-> 13                                                                                 |
|    |•  << Décalage des bits vers la gauche sur un BIGINT.                                 |
|    |                                                                                      |
|    |mysql> select 1 << 2                                                                  |
|    |-> 4                                                                                  |
|    |•  >> Décalage des bits vers la droite sur un BIGINT.                                 |
|    |                                                                                      |
|    |mysql> select 4 >> 2                                                                  |
|    |-> 1                                                                                  |
|    |•  BIT_COUNT(N) Compte le nombre de bits mis à un dans l'argument N.                  |
|    |                                                                                      |
|    |mysql> select BIT_COUNT(29);                                                          |
|    |-> 4                                                                                  |
|    |7.3.4 Opérations logiques                                                             |
|    |Toutes les opérations logiques retournent 1 (TRUE) ou 0 (FALSE).                      |
|    |•  NOT                                                                                |
|    |•  ! NON logique. Retourne 1 si l'argument est 0, sinon, retourne 0. Exception: NOT   |
|    |NULL retourne NULL.                                                                   |
|    |                                                                                      |
|    |mysql> select NOT 1;                                                                  |
|    |-> 0                                                                                  |
|    |mysql> select NOT NULL;                                                               |
|    |-> NULL                                                                               |
|    |mysql> select ! (1+1);                                                                |
|    |-> 0                                                                                  |
|    |mysql> select ! 1+1;                                                                  |
|    |-> 1                                                                                  |
|    |Le dernier exemple retourne 1 car l'expression est évaluée de la même façon que       |
|    |(!1)+1.                                                                               |
|    |•  OR                                                                                 |
|    |•  || OU logique. Retourne 1 si l'un des arguments est ni 0 ni NULL.                  |
|    |                                                                                      |
|    |mysql> select 1 || 0;                                                                 |
|    |-> 1                                                                                  |
|    |mysql> select 0 || 0;                                                                 |
|    |-> 0                                                                                  |
|    |mysql> select 1 || NULL;                                                              |
|    |-> 1                                                                                  |
|    |•  AND                                                                                |
|    |•  && ET logique. Retourne 0 si l'un des arguments est 0 ou NULL. Sinon, retourne 1.  |
|    |                                                                                      |
|    |mysql> select 1 && NULL;                                                              |
|    |-> 0                                                                                  |
|    |mysql> select 1 && 0;                                                                 |
|    |-> 0                                                                                  |
|    |7.3.5 Opérateurs de comparaison                                                       |
|    |Les opérations de comparaison retourne soit 1 (TRUE), 0 (FALSE) ou NULL. Ces fonctions|
|    |s'appliquent aussi bien aux nombres qu'aux chaînes. Les chaînes sont automatiquement  |
|    |converties en nombre et les nombres en chaîne, suivant les besoins (comme en Perl).   |
|    |MySQL effectue les comparaisons en suivant les règle suivantes                        |
|    |Si l'un au moins des argument est NULL, le résultat de la comparaison est NULL.       |
|    |Si les deux argument sont des chaînes, ils se comparent en tant que chaînes.          |
|    |Si les deux argument sont des entiers, ils se comparent en tant que entiers.          |
|    |Si les deux argument est de type TIMESTAMP ou DATETIME, et l'autre argument est une   |
|    |constante, la constante est convertie au format TIMESTAMP avant la comparaison. Cette |
|    |fonction est faite pour assurer la compatibilité ODBC.                                |
|    |Dans tous les autres cas, les arguments sont comparés en tant que nombre à virgule    |
|    |flottante.                                                                            |
|    |Par défaut, les comparaisons de chaîne sont fait sans tenir compte de la casse, et en |
|    |utilisant le jeu de caractère courant (ISO-8859-1 Latin1 par défaut, qui fonctionne   |
|    |bien pour l'anglais). Les exemples suivants illustrent les règles de conversions lors |
|    |des opérations de comparaison.                                                        |
|    |                                                                                      |
|    |mysql> SELECT 1 > '6x';                                                               |
|    |-> 0                                                                                  |
|    |mysql> SELECT 7 > '6x';                                                               |
|    |-> 1                                                                                  |
|    |mysql> SELECT 0 > 'x6';                                                               |
|    |-> 0                                                                                  |
|    |mysql> SELECT 0 = 'x6';                                                               |
|    |-> 1                                                                                  |
|    |•  = Egalité.                                                                         |
|    |                                                                                      |
|    |mysql> select 1 = 0;                                                                  |
|    |-> 0                                                                                  |
|    |mysql> select '0' = 0;                                                                |
|    |-> 1                                                                                  |
|    |mysql> select '0.0' = 0;                                                              |
|    |-> 1                                                                                  |
|    |mysql> select '0.01' = 0;                                                             |
|    |-> 0                                                                                  |
|    |mysql> select '.01' = 0.01;                                                           |
|    |-> 1                                                                                  |
|    |•  <>                                                                                 |
|    |•  != Différent                                                                       |
|    |                                                                                      |
|    |mysql> select '.01' <> '0.01';                                                        |
|    |-> 1                                                                                  |
|    |mysql> select .01 <> '0.01';                                                          |
|    |-> 0                                                                                  |
|    |mysql> select 'zorro' <> 'zorrro';                                                    |
|    |-> 1                                                                                  |
|    |•  <= Inférieur ou égal                                                               |
|    |                                                                                      |
|    |mysql> select 0.1 <= 2;                                                               |
|    |-> 1                                                                                  |
|    |•  < Strictement inférieur                                                            |
|    |                                                                                      |
|    |mysql> select 2 <= 2;                                                                 |
|    |-> 1                                                                                  |
|    |•  >= Supérieur ou égal                                                               |
|    |                                                                                      |
|    |mysql> select 2 >= 2;                                                                 |
|    |-> 1                                                                                  |
|    |•  > Strictement supérieur                                                            |
|    |                                                                                      |
|    |mysql> select 2 > 2;                                                                  |
|    |-> 0                                                                                  |
|    |•  <=> Egalité : ce opérateur s'assure qu'on ne compare pas NULL et une valeur non    |
|    |nulle.                                                                                |
|    |                                                                                      |
|    |mysql> select 1 <=> 1, NULL <=> NULL, 1 <=> NULL;                                     |
|    |-> 1 1 0                                                                              |
|    |•  expression BETWEEN minimum AND maximum Si l'expression est comprise entre le       |
|    |minimum et le maximum, alors BETWEEN retourne 1, sinon 0. Cette fonction est          |
|    |équivalente à l'expression (minimum <= expression AND expression <= maximum) si tous  |
|    |les arguments sont du même type. Le premier argument (expression) détermine la manière|
|    |dont la comparaison va être faite. Si expression est une chaîne, la comparaison sera  |
|    |de type chaîne, et insensible à la casse. Si expression est une chaîne de type        |
|    |binaire, la comparaison sera de type chaîne, et sensible à la casse. Si expression est|
|    |un entier, la comparaison sera de type numérique. Si expression est un nombre à       |
|    |virgule flottante, la comparaison sera de type numérique, à virgule flottante.        |
|    |                                                                                      |
|    |mysql> select 1 BETWEEN 2 AND 3;                                                      |
|    |-> 0                                                                                  |
|    |mysql> select 'b' BETWEEN 'a' AND 'c';                                                |
|    |-> 1                                                                                  |
|    |mysql> select 2 BETWEEN 2 AND '3';                                                    |
|    |-> 1                                                                                  |
|    |mysql> select 2 BETWEEN 2 AND 'x-3';                                                  |
|    |-> 0                                                                                  |
|    |•  expression IN (value,...) Retourne 1 si expression est un membre de la liste IN,   |
|    |sinon retourne 0.Si toutes les valeurs de la liste IN sont constantes, alors elles    |
|    |sont toutes converties au type de expression, et triées. La recherche dans la listes  |
|    |est alors faite avec une recherche binaire. Cela signifie que la recherche est très   |
|    |rapide si la liste IN ne contient que des constantes. Si expression est une chaîne    |
|    |sensible à la casse, la comparaison avec les valeurs de IN en tiendra compte.         |
|    |                                                                                      |
|    |mysql> select 2 IN (0,3,5,'wefwf');                                                   |
|    |-> 0                                                                                  |
|    |mysql> select 'wefwf' IN (0,3,5,'wefwf');                                             |
|    |-> 1                                                                                  |
|    |•  expression NOT IN (value,...) Identique à NOT (expression IN (value,...)).         |
|    |•  ISNULL(expression ) Si expression est NULL, ISNULL() retourne 1, sinon 0.          |
|    |                                                                                      |
|    |mysql> select ISNULL(1+1);                                                            |
|    |-> 0                                                                                  |
|    |mysql> select ISNULL(1/0);                                                            |
|    |-> 1                                                                                  |
|    |Il faut noter que la comparaison à NULL avec = sera toujours fausse!                  |
|    |•  COALESCE(liste) Retourne le premier élément non NULL dans la liste.                |
|    |                                                                                      |
|    |mysql> select COALESCE(NULL,1);                                                       |
|    |-> 1                                                                                  |
|    |mysql> select ISNULL(NULL,NULL,NULL);                                                 |
|    |-> NULL                                                                               |
|    |•  INTERVAL(N,N1,N2,N3,...) Retourne 1 si N1 < N2 < N3 < ... < Nn . Si il existe deux |
|    |valeurs i et j, telles que i < j et Ni > Nj, alors la fonction retourne faux. Toutes  |
|    |les valeurs sont traitées comme des nombres. Cela permet l'utilisation d'une          |
|    |comparaison binaire, très rapide.                                                     |
|    |                                                                                      |
|    |mysql> select INTERVAL(23, 1, 15, 17, 30, 44, 200);                                   |
|    |-> 3                                                                                  |
|    |mysql> select INTERVAL(10, 1, 10, 100, 1000);                                         |
|    |-> 2                                                                                  |
|    |mysql> select INTERVAL(22, 23, 30, 44, 200);                                          |
|    |-> 0                                                                                  |
|    |7.3.6 Fonctions de comparaisons des chaînes                                           |
|    |Dans une expression quelconque, si une des chaînes est sensible à la casse, alors la  |
|    |comparaison tiendra compte de la casse.                                               |
|    |•  expr1 LIKE expr2 [ESCAPE 'escape-char'] Expression régulière SQL. Retourne 1 (TRUE)|
|    |ou 0 (FALSE). Avec LIKE, les caractères spéciaux suivants sont disponibles :          |
|    |                                                                                      |
|    |mysql> select 'David!' LIKE 'David_';                                                 |
|    |-> 1                                                                                  |
|    |mysql> select 'David!' LIKE '%D%v%';                                                  |
|    |-> 1                                                                                  |
|    |Pour tester la présence d'un des caractères spéciaux, il suffit de faire précéder du  |
|    |caractère d'échappement. Si ce dernier n'est pas précisé, le caractère ``\'' est alors|
|    |utilisé.                                                                              |
|    |                                                                                      |
|    |mysql> select 'David!' LIKE 'David\_';                                                |
|    |-> 0                                                                                  |
|    |mysql> select 'David_' LIKE 'David\_';                                                |
|    |-> 1                                                                                  |
|    |Pour spécifier un autre caractère d'échappement, il faut utiliser la clause ESCAPE :  |
|    |                                                                                      |
|    |mysql> select 'David_' LIKE 'David|_' ESCAPE '|';                                     |
|    |-> 1                                                                                  |
|    |LIKE peut travailler avec des expressions numériques (c'est une extension de la norme |
|    |ANSI SQL.)                                                                            |
|    |                                                                                      |
|    |mysql> select 10 LIKE '1%';                                                           |
|    |-> 1                                                                                  |
|    |Note: Comme MySQL utilise le système d'échappement du langage C (e.g., ``\n''), il    |
|    |faut doubler toutes les occurrences dans les clause LIKE. Par exemple, pour rechercher|
|    |le caractère ``\n'', il faut mettre la chaîne ``\\n''. Pour recherche le caractère for|
|    |``\'', il faut l'écrire ``\\\\'' (les backslashes sont supprimés une première fois par|
|    |l'analyseur syntaxique, et une deuxième fois, quand la recherche est terminée : ce qui|
|    |laisse un seul backslash à rechercher).                                               |
|    |•  •  expr1 NOT LIKE expr2 [ESCAPE 'escape-char'] Identique à NOT (expr1 LIKE expr2   |
|    |[ESCAPE 'escape-char']).                                                              |
|    |•  expr REGEXP pat                                                                    |
|    |•  expr RLIKE pat                                                                     |
|    |•  expression REGEXP pat                                                              |
|    |•  expression RLIKE pat Effectue une chercher sur la chaîne expression avec le masque |
|    |pat. Le pattern peut être une expression régulière étendue. Retoune 1 si l'expression |
|    |régulière réussit, 0. RLIKE est un synonyme pour REGEXP, fourni pour assurer la       |
|    |compatibilité avec mSQL Note: Comme MySQL utilise le système d'échappement du langage |
|    |C (e.g., ``\n''), il faut doubler toutes les occurrences dans les clause. REGEXP .    |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select 'Monty!' REGEXP 'm%y%%';                                                |
|    |-> 0                                                                                  |
|    |mysql> select 'Monty!' REGEXP '.*';                                                   |
|    |-> 1                                                                                  |
|    |mysql> select 'new*\n*line' REGEXP 'new\\*.\\*line';                                  |
|    |-> 1                                                                                  |
|    |REGEXP et RLIKE utilisent le jeu de caractère (ISO-8859-1 Latin1 par défaut) pour     |
|    |choisir le type de caractère.                                                         |
|    |•  expr NOT REGEXP pat                                                                |
|    |•  expr NOT RLIKE pat                                                                 |
|    |•  expression NOT REGEXP expression Identique à NOT (expression REGEXP expression ).  |
|    |•  STRCMP(expr1,expr2) STRCMP() retourne 0 si les chaînes sont identiques, -1 si le   |
|    |premier argument est plus petit que le second, en fonction de l'ordre de tri courant, |
|    |et sinon 1 .                                                                          |
|    |                                                                                      |
|    |mysql> select STRCMP('text', 'text2');                                                |
|    |-> -1                                                                                 |
|    |mysql> select STRCMP('text2', 'text');                                                |
|    |-> 1                                                                                  |
|    |mysql> select STRCMP('text', 'text');                                                 |
|    |-> 0                                                                                  |
|    |7.3.7 Opérateurs de transtypage                                                       |
|    |•  BINARY L'opérateur BINARY transforme la chaîne qui le suive en chaîne insensible à |
|    |la casse. C'est un moyen simple de forcer une comparaison insensible à la casse, même |
|    |si la colonne n'a pas été définie comme un BINARY ou BLOB.                            |
|    |                                                                                      |
|    |mysql> select "a" = "A";                                                              |
|    |-> 1                                                                                  |
|    |mysql> select BINARY "a" = "A";                                                       |
|    |-> 0                                                                                  |
|    |BINARY a été introduit dans MySQL 3.23.0                                              |
|    |7.3.8 Fonctions de contrôle                                                           |
|    |•  IFNULL(expr1,expr2) Si expr1 n'est pas NULL, IFNULL() retourne expr1, sinon expr2. |
|    |IFNULL() retourne un nombre ou une chaîne, en fonction du contexte dans lequel il est |
|    |utilisé.                                                                              |
|    |                                                                                      |
|    |mysql> select IFNULL(1,0);                                                            |
|    |-> 1                                                                                  |
|    |mysql> select IFNULL(0,10);                                                           |
|    |-> 0                                                                                  |
|    |mysql> select IFNULL(1/0,10);                                                         |
|    |-> 10                                                                                 |
|    |mysql> select IFNULL(1/0,'yes');                                                      |
|    |-> 'yes'                                                                              |
|    |•  IF(expr1,expr2,expr3) Si expr1 est vraie (TRUE) (expr1 <> 0 et expr1 <> NULL) alors|
|    |IF() retourne expr2, sinon il retourne expr3. IF() retourne un nombre ou une chaîne,  |
|    |en fonction du contexte dans lequel il est utilisé.                                   |
|    |                                                                                      |
|    |mysql> select IF(1>2,2,3);                                                            |
|    |-> 3                                                                                  |
|    |mysql> select IF(1<2,'yes','no');                                                     |
|    |-> 'yes'                                                                              |
|    |mysql> select IF(strcmp('test','test1'),'yes','no');                                  |
|    |-> 'no'                                                                               |
|    |expr1 est évaluée en tant qu'entier, ce qui signifie que si le test portait sur un    |
|    |nombre à virgule flottante ou une chaîne, il faudrait mieux utiliser un opérateur de  |
|    |comparaison.                                                                          |
|    |                                                                                      |
|    |mysql> select IF(0.1,1,0);                                                            |
|    |-> 0                                                                                  |
|    |mysql> select IF(0.1<>0,1,0);                                                         |
|    |-> 1                                                                                  |
|    |Dans le premier cas ci-dessus, IF(0.1) retourne 0 car 0.1 est converti en un nombre   |
|    |entier, ce qui conduit à un test de type IF(0). C'est une source d'erreur. Dans le    |
|    |deuxième cas, la comparaison est faite avec un opérateur de comparaison, qui teste la |
|    |non nullité. Le résultat de la comparaison est utilisé comme un entier.               |
|    |•  CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] |
|    |[ELSE result] END                                                                     |
|    |•  CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] |
|    |END La première version retourne result si value=compare-value. La seconde version    |
|    |retourne le résultat si la première condition est vraie. Si il n'y a aucun résultat,  |
|    |alors, le résultat après ELSE est retourné. SI il n'y a pas de résultat pour ELSE     |
|    |alors NULL.                                                                           |
|    |                                                                                      |
|    |mysql> SELECT CASE 1 WHEN 1 THEN "un" WHEN 2 THEN "deux" ELSE "plus" END;             |
|    |-> "un"                                                                               |
|    |mysql> SELECT CASE WHEN 1>0 THEN "vrai" ELSE "faux" END;                              |
|    |-> "vrai"                                                                             |
|    |mysql> SELECT CASE BINARY "B" when "a" then 1 when "b" then 2 END;                    |
|    |-> NULL                                                                               |
|    |7.3.9 Fonctions mathématiques                                                         |
|    |Toutes les fonctions mathématiques retourne NULL en cas d'erreur.                     |
|    |•  - Moins unaire. Change le signe de l'argument.                                     |
|    |                                                                                      |
|    |mysql> select - 2;                                                                    |
|    |-> -2                                                                                 |
|    |Note : si cet opérateur est utilisé avec un BIGINT, le résultat sera BIGINT! Cela     |
|    |signifie qu'il faut éviter d'utiliser – sur des entiers qui ont la valeur -2^63!      |
|    |•  ABS(X) Valeur absolue de X.                                                        |
|    |                                                                                      |
|    |mysql> select ABS(2);                                                                 |
|    |-> 2                                                                                  |
|    |mysql> select ABS(-32);                                                               |
|    |-> 32                                                                                 |
|    |Cette fonction ne pose aucun problème particulier avec les valeurs de type BIGINT.    |
|    |•  SIGN(X) Retourne le signe de l'argument sous la forme -1, 0 or 1, suivant que X est|
|    |négatif, nul, ou positif.                                                             |
|    |                                                                                      |
|    |mysql> select SIGN(-32);                                                              |
|    |-> -1                                                                                 |
|    |mysql> select SIGN(0);                                                                |
|    |-> 0                                                                                  |
|    |mysql> select SIGN(234);                                                              |
|    |-> 1                                                                                  |
|    |•  MOD(N,M)                                                                           |
|    |•  % Modulo (identique à l'opérateur % en langage C). Retourne le reste de la division|
|    |euclidienne de N par M.                                                               |
|    |                                                                                      |
|    |mysql> select MOD(234, 10);                                                           |
|    |-> 4                                                                                  |
|    |mysql> select 253 % 7;                                                                |
|    |-> 1                                                                                  |
|    |mysql> select MOD(29,9);                                                              |
|    |-> 2                                                                                  |
|    |Cette fonction ne pose aucun problème particulier avec les valeurs de type BIGINT.    |
|    |•  FLOOR(X) Retourne le plus grand entier possible mais plus petit que X.             |
|    |                                                                                      |
|    |mysql> select FLOOR(1.23);                                                            |
|    |-> 1                                                                                  |
|    |mysql> select FLOOR(-1.23);                                                           |
|    |-> -2                                                                                 |
|    |Note : le résultat est converti en BIGINT!                                            |
|    |•  CEILING(X) Retourne le plus petit entier possible mais plus grand que X.           |
|    |                                                                                      |
|    |mysql> select CEILING(1.23);                                                          |
|    |-> 2                                                                                  |
|    |mysql> select CEILING(-1.23);                                                         |
|    |-> -1                                                                                 |
|    |Note : le résultat est converti en BIGINT!                                            |
|    |•  ROUND(X) Retourne l'argument X, arrondi à l'entier le plus proche.                 |
|    |                                                                                      |
|    |mysql> select ROUND(-1.23);                                                           |
|    |-> -1                                                                                 |
|    |mysql> select ROUND(-1.58);                                                           |
|    |-> -2                                                                                 |
|    |mysql> select ROUND(1.58);                                                            |
|    |-> 2                                                                                  |
|    |Note : le résultat est converti en BIGINT!                                            |
|    |•  ROUND(X,D) Retourne l'argument X, arrondi au décimal le plus proche, avec D        |
|    |décimales. Si D =0, le résultat n'aura pas de partie décimale.                        |
|    |                                                                                      |
|    |mysql> select ROUND(1.298, 1);                                                        |
|    |-> 1.3                                                                                |
|    |mysql> select ROUND(1.298, 0);                                                        |
|    |-> 1                                                                                  |
|    |Note : le résultat est converti en BIGINT!                                            |
|    |•  EXP(X) Retourne la valeur de e (base des logarithmes naturels ou népériens) à la   |
|    |puissance X.                                                                          |
|    |                                                                                      |
|    |mysql> select EXP(2);                                                                 |
|    |-> 7.389056                                                                           |
|    |mysql> select EXP(-2);                                                                |
|    |-> 0.135335                                                                           |
|    |•  LOG(X) Retourne le logarithme naturel de X.                                        |
|    |                                                                                      |
|    |mysql> select LOG(2);                                                                 |
|    |-> 0.693147                                                                           |
|    |mysql> select LOG(-2);                                                                |
|    |-> NULL                                                                               |
|    |Pour obtenir la valeur du logarithme de X dans une base arbitraire, il faut utiliser  |
|    |la formule LOG(X)/LOG(B).                                                             |
|    |•  LOG10(X) Retourne le logarithme de X en base 10.                                   |
|    |                                                                                      |
|    |mysql> select LOG10(2);                                                               |
|    |-> 0.301030                                                                           |
|    |mysql> select LOG10(100);                                                             |
|    |-> 2.000000                                                                           |
|    |mysql> select LOG10(-100);                                                            |
|    |-> NULL                                                                               |
|    |•  POW(X,Y)                                                                           |
|    |•  POWER(X,Y) Retourne la valeur de X à la puissance Y.                               |
|    |                                                                                      |
|    |mysql> select POW(2,2);                                                               |
|    |-> 4.000000                                                                           |
|    |mysql> select POW(2,-2);                                                              |
|    |-> 0.250000                                                                           |
|    |•  SQRT(X) Retourne la racine carrée positive de X.                                   |
|    |                                                                                      |
|    |mysql> select SQRT(4);                                                                |
|    |-> 2.000000                                                                           |
|    |mysql> select SQRT(20);                                                               |
|    |-> 4.472136                                                                           |
|    |•  PI() Retourne la valeur de PI.                                                     |
|    |                                                                                      |
|    |mysql> select PI();                                                                   |
|    |-> 3.141593                                                                           |
|    |•  COS(X) Retourne le cosinus de X, avec X en radians.                                |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select COS(PI());                                                              |
|    |-> -1.000000                                                                          |
|    |•  SIN(X) Retourne le sinus de X, avec X en radians.                                  |
|    |                                                                                      |
|    |mysql> select SIN(PI());                                                              |
|    |-> 0.000000                                                                           |
|    |•  TAN(X) Retourne la tangente de X, avec X en radians.                               |
|    |                                                                                      |
|    |mysql> select TAN(PI()+1);                                                            |
|    |-> 1.557408                                                                           |
|    |•  ACOS(X) Retourne l'arcosinus de X, c'est à dire l'angle dont le cosinus est X en   |
|    |radians. Retourne NULL si X n'est pas compris entre -1 et 1.                          |
|    |                                                                                      |
|    |mysql> select ACOS(1);                                                                |
|    |-> 0.000000                                                                           |
|    |mysql> select ACOS(1.0001);                                                           |
|    |-> NULL                                                                               |
|    |mysql> select ACOS(0);                                                                |
|    |-> 1.570796                                                                           |
|    |•  ASIN(X) Retourne l'arsinus de X, c'est à dire l'angle dont le sinus est X en       |
|    |radians. Retourne NULL si X n'est pas compris entre -1 et 1.                          |
|    |                                                                                      |
|    |mysql> select ASIN(0.2);                                                              |
|    |-> 0.201358                                                                           |
|    |mysql> select ASIN('foo');                                                            |
|    |-> 0.000000                                                                           |
|    |•  ATAN(X) Retourne l'arctangente de X, c'est à dire l'angle dont la tangente est X en|
|    |radians.                                                                              |
|    |                                                                                      |
|    |mysql> select ATAN(2);                                                                |
|    |-> 1.107149                                                                           |
|    |mysql> select ATAN(-2);                                                               |
|    |-> -1.107149                                                                          |
|    |•  ATAN2(X,Y) Retourne l'arc tangente de deux variables X et Y. C'est le même calcul  |
|    |que arc tangent of Y / X, hormis le fait que les signes des deux arguments est utilisé|
|    |pour déterminer le quadrant du résultat.                                              |
|    |                                                                                      |
|    |mysql> select ATAN(-2,2);                                                             |
|    |-> -0.785398                                                                          |
|    |mysql> select ATAN(PI(),0);                                                           |
|    |-> 1.570796                                                                           |
|    |•  COT(X) Retourne la cotangente de X.                                                |
|    |                                                                                      |
|    |mysql> select COT(12);                                                                |
|    |-> -1.57267341                                                                        |
|    |mysql> select COT(0);                                                                 |
|    |-> NULL                                                                               |
|    |•  RAND()                                                                             |
|    |•  RAND(N) Retourne un nombre aléatoire, compris entre 0 et 1.0. Si un entier N est   |
|    |précisé, il est utilisé comme valeur de seed.                                         |
|    |                                                                                      |
|    |mysql> select RAND();                                                                 |
|    |-> 0.5925                                                                             |
|    |mysql> select RAND(20);                                                               |
|    |-> 0.1811                                                                             |
|    |mysql> select RAND(20);                                                               |
|    |-> 0.1811                                                                             |
|    |mysql> select RAND();                                                                 |
|    |-> 0.2079                                                                             |
|    |mysql> select RAND();                                                                 |
|    |-> 0.7888                                                                             |
|    |Il est impossible d'utiliser une colonne de valeur RAND() avec la clause ORDER BY ,   |
|    |car la colonne sera évalué plusieurs fois. Avec MySQL 3.23, il est cependant possible |
|    |d'écrire: SELECT * FROM Nom_table ORDER BY RAND(). Comme cela, il est possible de     |
|    |faire une sélection aléatoire d'une table : SELECT * FROM table1,table2 WHERE a=b AND |
|    |c<d ORDER BY RAND() LIMIT 1000.                                                       |
|    |•  LEAST(X,Y,...) Au moins deux arguments, retourne la plus petite valeur (minimum).  |
|    |Les arguments sont comparés en utilisant les règles suivantes :                       |
|    |                                                                                      |
|    |Si LEAST est utilisé dans un contexte d'entiers, ou bien tous les arguments sont des  |
|    |entiers, les arguments sont évalués et comparés en tant qu'entiers.                   |
|    |                                                                                      |
|    |Si LEAST est utilisé dans un contexte de nombre à virgule flottante, les arguments    |
|    |sont évalués et comparés en tant que nombre à virgule flottante.                      |
|    |                                                                                      |
|    |Si tous les arguments sont des chaînes sensibles à la casse, tous les arguments sont  |
|    |comparés comme des chaînes insensibles à la casse.                                    |
|    |                                                                                      |
|    |Dans tous les autres cas, les arguments sont comparés comme des chaînes insensibles à |
|    |la casse.                                                                             |
|    |                                                                                      |
|    |mysql> select LEAST(2,0);                                                             |
|    |-> 0                                                                                  |
|    |mysql> select LEAST(34.0,3.0,5.0,767.0);                                              |
|    |-> 3.0                                                                                |
|    |mysql> select LEAST("B","A","C");                                                     |
|    |-> "A"                                                                                |
|    |Avec les version de MySQL antérieur à la 3.22.5, il est possible d'utiliser MIN() à la|
|    |place de LEAST.                                                                       |
|    |•  GREATEST(X,Y,...) Retourne le plus grand argument de la liste. Les arguments sont  |
|    |comparés de la même manière que pour LEAST.                                           |
|    |                                                                                      |
|    |mysql> select GREATEST(2,0);                                                          |
|    |-> 2                                                                                  |
|    |mysql> select GREATEST(34.0,3.0,5.0,767.0);                                           |
|    |-> 767.0                                                                              |
|    |mysql> select GREATEST("B","A","C");                                                  |
|    |-> "C"                                                                                |
|    |Avec les version de MySQL antérieur à la 3.22.5, il est possible d'utiliser MAX () à  |
|    |la place de GREATEST.                                                                 |
|    |•  DEGREES(X) Retourne l'argument X, converti de radians en degrés.                   |
|    |                                                                                      |
|    |mysql> select DEGREES(PI());                                                          |
|    |-> 180.000000                                                                         |
|    |•  RADIANS(X) Retourne l'argument X, converti de radians degrés en radians.           |
|    |                                                                                      |
|    |mysql> select RADIANS(90);                                                            |
|    |-> 1.570796                                                                           |
|    |•  TRUNCATE(X,D) Retourne l'argument X, tronqué à D décimales.                        |
|    |                                                                                      |
|    |mysql> select TRUNCATE(1.223,1);                                                      |
|    |-> 1.2                                                                                |
|    |mysql> select TRUNCATE(1.999,1);                                                      |
|    |-> 1.9                                                                                |
|    |mysql> select TRUNCATE(1.999,0);                                                      |
|    |-> 1                                                                                  |
|    |7.3.10 Fonctions de chaînes                                                           |
|    |Les fonctions qui retourne des chaînes, retourneront NULL si le résultat dépasse la   |
|    |taille maximale de max_allowed_packet.                                                |
|    |Pour les opérations sur les chaînes, le premier caractère est en position 1.          |
|    |•  ASCII(str) Retourne le code ASCII du premier caractère de la chaîne. Si la chaîne  |
|    |est vide, retourne 0. Si la chaîne est NULL, retourne NULL.                           |
|    |                                                                                      |
|    |mysql> select ASCII('2');                                                             |
|    |-> 50                                                                                 |
|    |mysql> select ASCII(2);                                                               |
|    |-> 50                                                                                 |
|    |mysql> select ASCII('dx');                                                            |
|    |-> 100                                                                                |
|    |•  CONV(N,from_base,to_base) Converti des nombres d'une base à l'autre, et retourne la|
|    |chaîne représentant le résultat converti. Si la chaîne est NULL, retourne NULL.       |
|    |L'argument N est considéré comme un entier, mais peut être un entier ou une chaîne. La|
|    |base minimum est 2, et maximum est 36. Si la base d'arrivée est un nombre négatif, N  |
|    |est considéré comme un entier signé. Sinon, N est traité comme un entiers non signé.  |
|    |CONV fonctionne à la précision 64 bits.                                               |
|    |                                                                                      |
|    |mysql> select CONV("a",16,2);                                                         |
|    |-> '1010'                                                                             |
|    |mysql> select CONV("6E",18,8);                                                        |
|    |-> '172'                                                                              |
|    |mysql> select CONV(-17,10,-18);                                                       |
|    |-> '-H'                                                                               |
|    |mysql> select CONV(10+"10"+'10'+0xa,10,10);                                           |
|    |-> '40'                                                                               |
|    |•  BIN(N) Retourne une chaîne représentant l'argument N en binaire. N est un BIGINT.  |
|    |Cette fonction est l'équivalent de CONV(N,10,2). Retourne NULL si N est NULL.         |
|    |                                                                                      |
|    |mysql> select BIN(12);                                                                |
|    |-> '1100'                                                                             |
|    |•  OCT(N) Retourne une chaîne représentant l'argument N en base 8. N est un BIGINT.   |
|    |Cette fonction est l'équivalent de CONV(N,10,8). Retourne NULL si N est NULL.         |
|    |                                                                                      |
|    |mysql> select OCT(12);                                                                |
|    |-> '14'                                                                               |
|    |•  HEX(N) Retourne une chaîne représentant l'argument N en hexadécimal. N est un      |
|    |BIGINT. Cette fonction est l'équivalent de CONV(N,10,16). Retourne NULL si N est NULL.|
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select HEX(255);                                                               |
|    |-> 'FF'                                                                               |
|    |•  CHAR(N,...) Interprète les arguments comme des nombres entiers, et retourne une    |
|    |chaîne constituée des caractères correspondant aux codes ASCII des arguments. Les     |
|    |valeurs NULL sont ignorées.                                                           |
|    |                                                                                      |
|    |mysql> select CHAR(77,121,83,81,'76');                                                |
|    |-> 'MySQL'                                                                            |
|    |mysql> select CHAR(77,77.3,'77.3');                                                   |
|    |-> 'MMM'                                                                              |
|    |•  CONCAT(X,Y,...) Concatène les arguments, et re tourne le résultat. Retourne NULL si|
|    |un des arguments est NULL. Le nombre d'argument minimum est 2.                        |
|    |                                                                                      |
|    |mysql> select CONCAT('My', 'S', 'QL');                                                |
|    |-> 'MySQL'                                                                            |
|    |mysql> select CONCAT('My', NULL, 'QL');                                               |
|    |-> NULL                                                                               |
|    |•  LONGUEUR(str)                                                                      |
|    |•  OCTET_LONGUEUR(str)                                                                |
|    |•  CHAR_LONGUEUR(str)                                                                 |
|    |•  CHARACTER_LONGUEUR(str) Retourne la longueur de la chaîne str.                     |
|    |                                                                                      |
|    |mysql> select LONGUEUR('text');                                                       |
|    |-> 4                                                                                  |
|    |mysql> select OCTET_LONGUEUR('text');                                                 |
|    |-> 4                                                                                  |
|    |•  LOCATE(substr,str)                                                                 |
|    |•  POSITION(substr IN str) Retourne la position de la première occurrence de substr   |
|    |dans la chaîne. Retourne 0 si substr n'est pas trouvée.                               |
|    |                                                                                      |
|    |mysql> select LOCATE('bar', 'foobarbar');                                             |
|    |-> 4                                                                                  |
|    |mysql> select LOCATE('xbar', 'foobar');                                               |
|    |-> 0                                                                                  |
|    |•  LOCATE(substr,str,pos) Retourne la position de la première occurrence de substr    |
|    |dans la chaîne, en commencant à chercher à partir de la position pos. Retourne 0 si   |
|    |substr n'est pas trouvée.                                                             |
|    |                                                                                      |
|    |mysql> select LOCATE('bar', 'foobarbar',5);                                           |
|    |-> 7                                                                                  |
|    |•  INSTR(str,substr) Retourne la position de la première occurrence de substr dans la |
|    |chaîne, en commencant à chercher à partir de la position pos. Retourne 0 si substr    |
|    |n'est pas trouvée. C'est la même fonction que LOCATE(), mais les deux arguments n'ont |
|    |pas la même place.                                                                    |
|    |                                                                                      |
|    |mysql> select INSTR('foobarbar', 'bar');                                              |
|    |-> 4                                                                                  |
|    |mysql> select INSTR('xbar', 'foobar');                                                |
|    |-> 0                                                                                  |
|    |•  LPAD(str,len,padstr) Retourne la chaîne str, complétée à gauche par la chaîne      |
|    |padstr jusqu'à ce que le résultat ait la longueur .                                   |
|    |                                                                                      |
|    |mysql> select LPAD('hi',4,'??');                                                      |
|    |-> '??hi'                                                                             |
|    |•  RPAD(str,len,padstr) Retourne la chaîne str, complétée à droite par la chaîne      |
|    |padstr jusqu'à ce que le résultat ait la longueur .                                   |
|    |                                                                                      |
|    |mysql> select RPAD('hi',5,'?');                                                       |
|    |-> 'hi???'                                                                            |
|    |•  LEFT(str,len) Retourne les len premiers caractères de la chaîne str.               |
|    |                                                                                      |
|    |mysql> select LEFT('foobarbar', 5);                                                   |
|    |-> 'fooba'                                                                            |
|    |•  RIGHT(str,len)                                                                     |
|    |•  SUBSTRING(str FROM len) Retourne les len derniers caractères de la chaîne str.     |
|    |                                                                                      |
|    |mysql> select RIGHT('foobarbar', 4);                                                  |
|    |-> 'rbar'                                                                             |
|    |mysql> select SUBSTRING('foobarbar' FROM 4);                                          |
|    |-> 'rbar'                                                                             |
|    |•  SUBSTRING(str,pos,len)                                                             |
|    |•  SUBSTRING(str FROM pos FOR len)                                                    |
|    |•  MID(str,pos,len) Retourne les len caractères de la chaîne str, en commencant à     |
|    |partir de la position pos. La variante FROM est une syntaxe issue de la norme ANSI    |
|    |SQL92.                                                                                |
|    |                                                                                      |
|    |mysql> select SUBSTRING('Quadratically',5,6);                                         |
|    |-> 'ratica'                                                                           |
|    |•  SUBSTRING(str,pos) Retourne une sous-chaîne, issue de str et commencant à la       |
|    |position pos.                                                                         |
|    |                                                                                      |
|    |mysql> select SUBSTRING('Quadratically',5);                                           |
|    |-> 'ratically'                                                                        |
|    |•  SUBSTRING_INDEX(str,delim,count) Retourne une sous-chaîne, issue de str, après     |
|    |count occurrences du délimiteur delim. Si count est positif, la sous-chaîne comprendra|
|    |tous les caractères situés à gauche du délimiteur final. Si count est négatif, la     |
|    |sous-chaîne comprendra tous les caractères situés à droite du délimiteur final        |
|    |                                                                                      |
|    |mysql> select SUBSTRING_INDEX('www.mysql.com', '.', 2);                               |
|    |-> 'www.mysql'                                                                        |
|    |mysql> select SUBSTRING_INDEX('www.mysql.com', '.', -2);                              |
|    |-> 'mysql.com'                                                                        |
|    |•  LTRIM(str) Retourne la chaîne str après élimination des espaces situés en début de |
|    |chaîne.                                                                               |
|    |                                                                                      |
|    |mysql> select LTRIM('  barbar');                                                      |
|    |-> 'barbar'                                                                           |
|    |•  RTRIM(str) retourne la chaîne str après élimination des espaces situés en fin de   |
|    |chaîne.                                                                               |
|    |                                                                                      |
|    |mysql> select RTRIM('barbar   ');                                                     |
|    |-> 'barbar'                                                                           |
|    |•  TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str) Retourne la chaîne str après |
|    |élimination de chaînes remstr situées en début et/ou fin de chaîne. Si aucune des     |
|    |options BOTH, LEADING ou TRAILING n'est précisé, alors BOTH est utilisé par défaut. Si|
|    |remstr n'est pas précisé, les espaces sont éliminés.                                  |
|    |                                                                                      |
|    |mysql> select TRIM('  bar   ');                                                       |
|    |-> 'bar'                                                                              |
|    |mysql> select TRIM(LEADING 'x' FROM 'xxxbarxxx');                                     |
|    |-> 'barxxx'                                                                           |
|    |mysql> select TRIM(BOTH 'x' FROM 'xxxbarxxx');                                        |
|    |-> 'bar'                                                                              |
|    |mysql> select TRIM(TRAILING 'xyz' FROM 'barxxyz');                                    |
|    |-> 'barx'                                                                             |
|    |•  SOUNDEX(str) Retourne une représentation phonétique de la chaîne . Deux chaînes qui|
|    |" sonne de la même façon " devraient avoir des représentation identiques. Une         |
|    |représentation standard a 4 caractères, mais SOUNDEX() retourne un nombre arbitraire  |
|    |de caractère. Il faudra alors utiliser SUBSTRING() sur le résultat pour avoir une     |
|    |représentation standard. Les caractères non-alphanumériques sont ignorés. Tous les    |
|    |caractères alphabétiques hors de l'intervalle A-Z sont considéré comme des voyelles.  |
|    |•  Attention : cette fonction ayant été programmé par des anglophones, la " sonorité "|
|    |d'une chaîne aura un fort accent anglais.                                             |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select SOUNDEX('Hello');                                                       |
|    |-> 'H400'                                                                             |
|    |mysql> select SOUNDEX('Quadratically');                                               |
|    |-> 'Q36324'                                                                           |
|    |•  SPACE(N) Crée une chaîne contenant N espaces.                                      |
|    |                                                                                      |
|    |mysql> select SPACE(6);                                                               |
|    |-> '      '                                                                           |
|    |•  REPLACE(str,from_str,to_str) Remplace les occurrences de from_str par la chaîne    |
|    |to_str, dans la chaîne str.                                                           |
|    |                                                                                      |
|    |mysql> select REPLACE('www.mysql.com', 'w', 'Ww');                                    |
|    |-> 'WwWwww.mysql.com'                                                                 |
|    |•  REPEAT(str,count) Retourne une chaîne constituée des répétitions de la chaîne . Si |
|    |count <= 0, retourne une chaîne vide. Si str ou count est NULL, retourne NULL.        |
|    |                                                                                      |
|    |mysql> select REPEAT('MySQL', 3);                                                     |
|    |-> 'MySQLMySQLMySQL'                                                                  |
|    |•  REVERSE(str) Inverse l'ordre des caractères de la chaîne str.                      |
|    |                                                                                      |
|    |mysql> select REVERSE('abc');                                                         |
|    |-> 'cba'                                                                              |
|    |•  INSERT(str,pos,len,newstr) Retourne la chaîne str, avec la chaîne newstr qui       |
|    |remplace tous les caractères à partir de la position pos, et sur la longueur len.     |
|    |                                                                                      |
|    |mysql> select INSERT('Quadratic', 3, 4, 'What');                                      |
|    |-> 'QuWhattic'                                                                        |
|    |•  ELT(N,str1,str2,str3,...) Retourne str1 si N = 1, str2 si N = 2, etc... Retourne   |
|    |NULL si est plus petit que 1 ou plus grand que le nombre d'arguments. ELT() est le    |
|    |contraire de FIELD().                                                                 |
|    |                                                                                      |
|    |mysql> select ELT(1, 'ej', 'Heja', 'hej', 'foo');                                     |
|    |-> 'ej'                                                                               |
|    |mysql> select ELT(4, 'ej', 'Heja', 'hej', 'foo');                                     |
|    |-> 'foo'                                                                              |
|    |•  FIELD(str,str1,str2,str3,...) Retourne l'index de la chaîne str dans la liste des  |
|    |arguments . Retourne 0 si str n'est pas trouvé .FIELD() est le contraire de ELT()     |
|    |                                                                                      |
|    |mysql> select FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');                         |
|    |-> 2                                                                                  |
|    |mysql> select FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');                         |
|    |-> 0                                                                                  |
|    |•  FIND_IN_SET(str,strlist) Retourne l'index de la chaîne dans la liste. Une liste de |
|    |chaîne est composée de chaînes, séparées par le caractère ``,''. Si le premier        |
|    |argument est une chaîne constante, et le deuxième est une colonne de type SET, la     |
|    |fonction est optimisée FIND_IN_SET() pour utiliser l'arithmétique sur les bits !      |
|    |Retourne str si n'est pas dans la liste strlist, ou si la liste est vide. Retourne    |
|    |NULL si l'un des arguments est NULL. La fonction n'accepte pas de caractère ``,''dans |
|    |le premier membre de la liste.                                                        |
|    |                                                                                      |
|    |mysql> SELECT FIND_IN_SET('b','a,b,c,d');                                             |
|    |-> 2                                                                                  |
|    |•  MAKE_SET(bits,str1,str2,...) Retourne un ensemble (une chaîne contenant des        |
|    |sous-chaînes séparée par ``,'') qui correspond à u sous-ensemble des chaînes en       |
|    |arguments. La chaîne à l'index i sera présente dans l'ensemble résultat, si le bit à  |
|    |l'index i est à un, dans bits).                                                       |
|    |                                                                                      |
|    |mysql> SELECT MAKE_SET(1,'a','b','c');                                                |
|    |-> 'a'                                                                                |
|    |mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');                                 |
|    |-> 'hello,world'                                                                      |
|    |mysql> SELECT MAKE_SET(0,'a','b','c');                                                |
|    |-> ''                                                                                 |
|    |•  EXPORT_SET(bits,on,off,[separator],[number_of_bits]) Retourne une chaîne dans      |
|    |laquelle, pour chaque bit à 1 , il y a la chaîne on, pour chaque bit à 0 , il y a la  |
|    |chaîne off, séparés par le separator (par défaut, ','), et uniquement pour les        |
|    |number_of_bits (par défaut, 64) premiers bits.                                        |
|    |                                                                                      |
|    |mysql> select EXPORT_SET(5,'Y','N',',',4)                                             |
|    |-> Y,N,Y,N                                                                            |
|    |•  LCASE(str)                                                                         |
|    |•  LOWER(str) Retourne la chaîne avec tous les caractères en minuscules, conformément |
|    |au jeu de caractère courant (par défaut, ISO-8859-1 Latin1).                          |
|    |                                                                                      |
|    |mysql> select LCASE('QUADRATICALLY');                                                 |
|    |-> 'quadratically'                                                                    |
|    |•  UCASE(str)                                                                         |
|    |•  UPPER(str) Retourne la chaîne avec tous les caractères en majuscule, conformément  |
|    |au jeu de caractère courant (par défaut, ISO-8859-1 Latin1).                          |
|    |                                                                                      |
|    |mysql> select UCASE('Hej');                                                           |
|    |-> 'HEJ'                                                                              |
|    |•  LOAD_FILE(Nom_fichier) Lit le fichier Nom_fichier et retourne le résultat dans une |
|    |chaîne. Le fichier doit être sur le serveur, et il faut préciser le nom et le chemin  |
|    |d'accès complet. Le fichier doit être lisible par tous, et être plus petit que        |
|    |max_allowed_packet. Si le fichier n'existe pas, ou ne peut être lu, la fonction       |
|    |retourne NULL.                                                                        |
|    |                                                                                      |
|    |mysql> UPDATE Nom_tableSET blob_column=LOAD_FILE("/tmp/picture") WHERE id=1;          |
|    |Il n'y a pas de fonction de conversion d'un nombre en char. Il n'y en pas besoin, car |
|    |MySQL converti automatiquement les nombres en chaînes, et vice versa.                 |
|    |                                                                                      |
|    |mysql> SELECT 1+"1";                                                                  |
|    |-> 2                                                                                  |
|    |mysql> SELECT CONCAT(2,' test');                                                      |
|    |-> '2 test'                                                                           |
|    |Si une fonction qui travaille sur des chaînes sensibles à la casse recoit comme       |
|    |argument une chaîne insensible à la casse, le resultat sera aussi une chaîne          |
|    |insensible à la casse. Un nombre converti en chaîne est traité comme une chaîne       |
|    |insensible à la casse. Cela n'affecte que les comparaisons.                           |
|    |7.3.11 Fonctions de date et heure                                                     |
|    |7.2.6 Types date et heure pour une description précise des intervalles de validité de |
|    |chaque type.                                                                          |
|    |Voici un exemple qui utilise des fonctions sur les dates et heures. La requête        |
|    |ci-dessous sélectionne toutes les lignes avec une valeur qui est date_col dans les 30 |
|    |derniers jours :                                                                      |
|    |                                                                                      |
|    |mysql> SELECT quelquechose FROM table                                                 |
|    |WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;                                       |
|    |•  DAYOFWEEK(date) Retourne le jour de la semaine sous la forme d'un index qui        |
|    |commence à 1 (1 = Dimanche, 2 = Lundi, ... 7 = Samedi). Ces valeurs sont celles du    |
|    |standard ODBC.                                                                        |
|    |                                                                                      |
|    |mysql> select DAYOFWEEK('1998-02-03');                                                |
|    |-> 3                                                                                  |
|    |•  WEEKDAY(date) Retourne le jour de la semaine sous la forme d'un index qui commence |
|    |à 0 (0 = Dimanche, 1 = Lundi, ... 6 = Samedi).                                        |
|    |                                                                                      |
|    |mysql> select WEEKDAY('1997-10-04 22:23:00');                                         |
|    |-> 5                                                                                  |
|    |mysql> select WEEKDAY('1997-11-05');                                                  |
|    |-> 2                                                                                  |
|    |•  DAYOFMONTH(date) Retourne le jour du mois sous la forme d'un index entre 1 et 31.  |
|    |                                                                                      |
|    |mysql> select DAYOFMONTH('1998-02-03');                                               |
|    |-> 3                                                                                  |
|    |•  DAYOFYEAR(date) Retourne le jour de l'année sous la forme d'un index entre 1 et    |
|    |366.                                                                                  |
|    |                                                                                      |
|    |mysql> select DAYOFYEAR('1998-02-03');                                                |
|    |-> 34                                                                                 |
|    |•  MONTH(date) Retourne le mois de la date sous la forme d'un index entre 1 et 12.    |
|    |                                                                                      |
|    |mysql> select MONTH('1998-02-03');                                                    |
|    |-> 2                                                                                  |
|    |•  DAYNAME(date) Retourne le nom du jour de la date sous la forme d'une chaîne (en    |
|    |anglais ).                                                                            |
|    |                                                                                      |
|    |mysql> select DAYNAME("1998-02-05");                                                  |
|    |-> 'Thursday'                                                                         |
|    |•  MONTHNAME(date) Retourne le nom du mois de la date sous la forme d'une chaîne (en  |
|    |anglais ).                                                                            |
|    |                                                                                      |
|    |mysql> select MONTHNAME("1998-02-05");                                                |
|    |-> 'February'                                                                         |
|    |•  QUARTER(date) Retourne le trimestre de la date sous la forme d'un index entre 1 et |
|    |4.                                                                                    |
|    |                                                                                      |
|    |mysql> select QUARTER('98-04-01');                                                    |
|    |-> 2                                                                                  |
|    |•  WEEK(date)                                                                         |
|    |•  WEEK(date,first) Avec un seul argument, retourne la semaine de la date sous la     |
|    |forme d'un index entre 1 à 52, avec Dimanche comme premier jour de la semaine. La     |
|    |fonction avec deux arguments permet de préciser si la semaine commence à Dimanche (0) |
|    |ou Lundi (1).                                                                         |
|    |                                                                                      |
|    |mysql> select WEEK('1998-02-20');                                                     |
|    |-> 7                                                                                  |
|    |mysql> select WEEK('1998-02-20',0);                                                   |
|    |-> 7                                                                                  |
|    |mysql> select WEEK('1998-02-20',1);                                                   |
|    |-> 8                                                                                  |
|    |•  YEAR(date) Retourne l'année de la date sous la forme d'un index entre 1000 et 9999.|
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select YEAR('98-02-03');                                                       |
|    |-> 1998                                                                               |
|    |•  HOUR(time) Retourne l'heure de la date sous la forme d'un index entre 0 et 23.     |
|    |                                                                                      |
|    |mysql> select HOUR('10:05:03');                                                       |
|    |-> 10                                                                                 |
|    |•  MINUTE(time) Retourne la minute de la date sous la forme d'un index entre 0 et 59. |
|    |                                                                                      |
|    |mysql> select MINUTE('98-02-03 10:05:03');                                            |
|    |-> 5                                                                                  |
|    |•  SECOND(time) Retourne la seconde de la date sous la forme d'un index entre 0 et 59.|
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> select SECOND('10:05:03');                                                     |
|    |-> 3                                                                                  |
|    |•  PERIOD_ADD(P,N) Ajoute N mois à la date P (au format YYMM ou YYYYMM). Retourne le  |
|    |résultat au format YYYYMM. Il faut bien noter que la date P n'est pas au format date. |
|    |                                                                                      |
|    |mysql> select PERIOD_ADD(9801,2);                                                     |
|    |-> 199803                                                                             |
|    |•  PERIOD_DIFF(P1,P2) Retourne le nombre de mois entre deux dates P1 et P2. P1 et P2  |
|    |doivent être au format . Il faut bien noter que les dates P1 et P2 ne sont pas au     |
|    |format date.                                                                          |
|    |                                                                                      |
|    |mysql> select PERIOD_DIFF(9802,199703);                                               |
|    |-> 11                                                                                 |
|    |•  DATE_ADD(date,INTERVAL expression type)                                            |
|    |•  DATE_SUB(date,INTERVAL expression type)                                            |
|    |•  ADDDATE(date,INTERVAL expression type)                                             |
|    |•  SUBDATE(date,INTERVAL expression type) Ces fonctions effectuent des opérations     |
|    |arithmétiques sur les dates. Elles ont été inserées dans MySQL 3.22. ADDDATE() et     |
|    |SUBDATE() sont synonymes de DATE_ADD() et DATE_SUB(). date est de type DATETIME ou    |
|    |DATE , qui indique la date de début. expression est une expression qui donne une durée|
|    |à ajouter ou à retrancher à la date de début. expression est une chaîne qui peut      |
|    |commencer par un signe moins (``-''), pour indiquer une durée négative. type est un   |
|    |mot clé qui indique comment l'expression doit être considéré. La table suivante       |
|    |établit la relation type et expression :                                              |
|    |type value                                                                            |
|    |Meaning                                                                               |
|    |Expected expr format                                                                  |
|    |                                                                                      |
|    |SECOND                                                                                |
|    |Seconds                                                                               |
|    |SECONDS                                                                               |
|    |                                                                                      |
|    |MINUTE                                                                                |
|    |Minutes                                                                               |
|    |MINUTES                                                                               |
|    |                                                                                      |
|    |HOUR                                                                                  |
|    |Hours                                                                                 |
|    |HOURS                                                                                 |
|    |                                                                                      |
|    |DAY                                                                                   |
|    |Days                                                                                  |
|    |DAYS                                                                                  |
|    |                                                                                      |
|    |MONTH                                                                                 |
|    |Months                                                                                |
|    |MONTHS                                                                                |
|    |                                                                                      |
|    |YEAR                                                                                  |
|    |Years                                                                                 |
|    |YEARS                                                                                 |
|    |                                                                                      |
|    |MINUTE_SECOND                                                                         |
|    |Minutes and seconds                                                                   |
|    |"MINUTES:SECONDS"                                                                     |
|    |                                                                                      |
|    |HOUR_MINUTE                                                                           |
|    |Hours and minutes                                                                     |
|    |"HOURS:MINUTES"                                                                       |
|    |                                                                                      |
|    |DAY_HOUR                                                                              |
|    |Days and hours                                                                        |
|    |"DAYS HOURS"                                                                          |
|    |                                                                                      |
|    |YEAR_MONTH                                                                            |
|    |Years and months                                                                      |
|    |"YEARS-MONTHS"                                                                        |
|    |                                                                                      |
|    |HOUR_SECOND                                                                           |
|    |Hours, minutes,                                                                       |
|    |"HOURS:MINUTES:SECONDS"                                                               |
|    |                                                                                      |
|    |DAY_MINUTE                                                                            |
|    |Days, hours, minutes                                                                  |
|    |"DAYS HOURS:MINUTES"                                                                  |
|    |                                                                                      |
|    |DAY_SECOND                                                                            |
|    |Days, hours, minutes, seconds                                                         |
|    |"DAYS HOURS:MINUTES:SECONDS"                                                          |
|    |                                                                                      |
|    |MySQL allows any non-numeric delimiter in the expr format. The ones shown in the table|
|    |are the suggested delimiters. If the date argument is a DATE value and your           |
|    |calculations involve only YEAR, MONTH and DAY parts (that is, no time parts), the     |
|    |result is a DATE value. Otherwise the result is a DATETIME value.                     |
|    |                                                                                      |
|    |mysql> SELECT DATE_ADD("1997-12-31 23:59:59",                                         |
|    |INTERVAL 1 SECOND);                                                                   |
|    |-> 1998-01-01 00:00:00                                                                |
|    |mysql> SELECT DATE_ADD("1997-12-31 23:59:59",                                         |
|    |INTERVAL 1 DAY);                                                                      |
|    |-> 1998-01-01 23:59:59                                                                |
|    |mysql> SELECT DATE_ADD("1997-12-31 23:59:59",                                         |
|    |INTERVAL "1:1" MINUTE_SECOND);                                                        |
|    |-> 1998-01-01 00:01:00                                                                |
|    |mysql> SELECT DATE_SUB("1998-01-01 00:00:00",                                         |
|    |INTERVAL "1 1:1:1" DAY_SECOND);                                                       |
|    |-> 1997-12-30 22:58:59                                                                |
|    |mysql> SELECT DATE_ADD("1998-01-01 00:00:00",                                         |
|    |INTERVAL "-1 10" DAY_HOUR);                                                           |
|    |-> 1997-12-30 14:00:00                                                                |
|    |mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);                                |
|    |-> 1997-12-02                                                                         |
|    |mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");                                        |
|    |-> 1999                                                                               |
|    |mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");                         |
|    |-> 199907                                                                             |
|    |mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");                         |
|    |-> 20102                                                                              |
|    |MySQL accepte l'utilisation de délimiteurs non-numériques dans le format de expression|
|    |. Ceux présentés dans le tableaux ne sont que des suggestions. Si l'argument date est |
|    |au format DATE et que les calculs font intervenir seulement YEAR, MONTH et DAY (c'est |
|    |à dire, juste la date, par l'heure.), le résultat est de type DATE . Sinon, le        |
|    |résultat des de type DATETIME .                                                       |
|    |                                                                                      |
|    |mysql> select DATE_ADD("1997-12-31 23:59:59",                                         |
|    |INTERVAL 1 SECOND);                                                                   |
|    |-> 1998-01-01 00:00:00                                                                |
|    |mysql> select DATE_ADD("1997-12-31 23:59:59",                                         |
|    |INTERVAL 1 DAY);                                                                      |
|    |-> 1998-01-01 23:59:59                                                                |
|    |mysql> select DATE_ADD("1997-12-31 23:59:59",                                         |
|    |INTERVAL "1:1" MINUTE_SECOND);                                                        |
|    |-> 1998-01-01 00:01:00                                                                |
|    |mysql> select DATE_SUB("1998-01-01 00:00:00",                                         |
|    |INTERVAL "1 1:1:1" DAY_SECOND);                                                       |
|    |-> 1997-12-30 22:58:59                                                                |
|    |mysql> select DATE_ADD("1998-01-01 00:00:00",                                         |
|    |INTERVAL "-1 10" DAY_HOUR);                                                           |
|    |-> 1997-12-30 14:00:00                                                                |
|    |mysql> select DATE_SUB("1998-01-02", INTERVAL 31 DAY);                                |
|    |-> 1997-12-02                                                                         |
|    |Si l'argument de durée est trop court par rapport au mot clé spécifié, MySQL suppose  |
|    |que les parties de gauche sont mises à zéro. Par exemple, avec le mot clé DAY_SECOND ,|
|    |s'attend à trouver le format "JOURS HEURES:MINUTES:SECONDES" . Si l'argument de durée |
|    |est "1:10", supposera que les jours et heures sont à 0, et que seules, les minutes et |
|    |secondes sont fournies. En un sens, MySQL ignore le type spécifié, et utilise à la    |
|    |place MINUTE_SECOND. Si les dates sont incorrectes, le résultat est NULL. Par         |
|    |ailleurs, lors de l'utilisation des options MONTH, YEAR_MONTH ou YEAR, et que dans le |
|    |mois résultant, la date du jours n'existe pas, elle est automatiquement ramenée à la  |
|    |plus grande valeur qu'elle peut prendre dans ce mois.                                 |
|    |                                                                                      |
|    |mysql> select DATE_ADD('1998-01-30', Interval 1 month);                               |
|    |-> 1998-02-28                                                                         |
|    |Note from the preceding example that the word INTERVAL and the type keyword are not   |
|    |case sensitive.                                                                       |
|    |•  TO_DAYS(date) Retourne l'index du jour par rapport au 1er janvier 0.               |
|    |                                                                                      |
|    |mysql> select TO_DAYS(950501);                                                        |
|    |-> 728779                                                                             |
|    |mysql> select TO_DAYS('1997-10-07');                                                  |
|    |-> 729669                                                                             |
|    |TO_DAYS() n'est pas prévu pour utiliser des dates précédents l'avènement du calendrier|
|    |Grégorien. (1582)..                                                                   |
|    |•  FROM_DAYS(N) Etant donné un numéro de jour par rapport au 1er janvier 0, retourne  |
|    |une valeur de type DATE.                                                              |
|    |                                                                                      |
|    |mysql> select FROM_DAYS(729669);                                                      |
|    |-> '1997-10-07'                                                                       |
|    |FROM_DAYS()n'est pas prévu pour utiliser des dates précédents l'avènement du          |
|    |calendrier Grégorien. (1582).                                                         |
|    |•  DATE_FORMAT(date,format) Formate la date date en fonction de la chaîne format. Les |
|    |formats suivants peuvent être utilisé dans format :                                   |
|    |%M                                                                                    |
|    |Month name (January..December)                                                        |
|    |                                                                                      |
|    |%W                                                                                    |
|    |Weekday name (Sunday..Saturday)                                                       |
|    |                                                                                      |
|    |%D                                                                                    |
|    |Day of the month with english suffix (1st, 2nd, 3rd, etc.)                            |
|    |                                                                                      |
|    |%Y                                                                                    |
|    |Year, numeric, 4 digits                                                               |
|    |                                                                                      |
|    |%y                                                                                    |
|    |Year, numeric, 2 digits                                                               |
|    |                                                                                      |
|    |%a                                                                                    |
|    |Abbreviated weekday name (Sun..Sat)                                                   |
|    |                                                                                      |
|    |%d                                                                                    |
|    |Day of the month, numeric (00..31)                                                    |
|    |                                                                                      |
|    |%e                                                                                    |
|    |Day of the month, numeric (0..31)                                                     |
|    |                                                                                      |
|    |%m                                                                                    |
|    |Month, numeric (01..12)                                                               |
|    |                                                                                      |
|    |%c                                                                                    |
|    |Month, numeric (1..12)                                                                |
|    |                                                                                      |
|    |%b                                                                                    |
|    |Abbreviated month name (Jan..Dec)                                                     |
|    |                                                                                      |
|    |%j                                                                                    |
|    |Day of year (001..366)                                                                |
|    |                                                                                      |
|    |%H                                                                                    |
|    |Hour (00..23)                                                                         |
|    |                                                                                      |
|    |%k                                                                                    |
|    |Hour (0..23)                                                                          |
|    |                                                                                      |
|    |%h                                                                                    |
|    |Hour (01..12)                                                                         |
|    |                                                                                      |
|    |%I                                                                                    |
|    |Hour (01..12)                                                                         |
|    |                                                                                      |
|    |%l                                                                                    |
|    |Hour (1..12)                                                                          |
|    |                                                                                      |
|    |%i                                                                                    |
|    |Minutes, numeric (00..59)                                                             |
|    |                                                                                      |
|    |%r                                                                                    |
|    |Time, 12-hour (hh:mm:ss [AP]M)                                                        |
|    |                                                                                      |
|    |%T                                                                                    |
|    |Time, 24-hour (hh:mm:ss)                                                              |
|    |                                                                                      |
|    |%S                                                                                    |
|    |Seconds (00..59)                                                                      |
|    |                                                                                      |
|    |%s                                                                                    |
|    |Seconds (00..59)                                                                      |
|    |                                                                                      |
|    |%p                                                                                    |
|    |AM or PM                                                                              |
|    |                                                                                      |
|    |%w                                                                                    |
|    |Day of the week (0=Sunday..6=Saturday)                                                |
|    |                                                                                      |
|    |%U                                                                                    |
|    |Week (0..52), where Sunday is the first day of the week                               |
|    |                                                                                      |
|    |%u                                                                                    |
|    |Week (0..52), where Monday is the first day of the week                               |
|    |                                                                                      |
|    |%%                                                                                    |
|    |A literal `%'.                                                                        |
|    |                                                                                      |
|    |Tous les autres caractères sont recopiés, sans interpretation                         |
|    |                                                                                      |
|    |mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');                         |
|    |-> 'Saturday October 1997'                                                            |
|    |mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');                         |
|    |-> '22:23:00'                                                                         |
|    |mysql> select DATE_FORMAT('1997-10-04 22:23:00',                                      |
|    |'%D %y %a %d %m %b %j');                                                              |
|    |-> '4th 97 Sat 04 10 Oct 277'                                                         |
|    |mysql> select DATE_FORMAT('1997-10-04 22:23:00',                                      |
|    |'%H %k %I %r %T %S %w');                                                              |
|    |-> '22 22 10 10:23:00 PM 22:23:00 00 6'                                               |
|    |Depuis MySQL 3.23, le caractère % est obligatoire devant le caractère de format. Dans |
|    |les versions antérieures de MySQL, % il était optionnel.                              |
|    |•  TIME_FORMAT(time,format) Utilisation identique à DATE_FORMAT(), mais seulement pour|
|    |les heures (heures, minutes secondes). Les autres arguments conduisent à un résultat a|
|    |NULL ou 0.                                                                            |
|    |•  CURDATE()                                                                          |
|    |•  CURRENT_DATE Retourne la date du jour, au format 'YYYY-MM-DD' ou YYYYMMDD , suivant|
|    |que la fonction est utilisée en contexte chaîne ou numérique                          |
|    |                                                                                      |
|    |mysql> select CURDATE();                                                              |
|    |-> '1997-12-15'                                                                       |
|    |mysql> select CURDATE() + 0;                                                          |
|    |-> 19971215                                                                           |
|    |•  CURTIME()                                                                          |
|    |•  CURRENT_TIME Retourne l'heure du jour, au format 'HH:MM:SS' or HHMMSS, suivant que |
|    |la fonction est utilisée en contexte chaîne ou numérique                              |
|    |                                                                                      |
|    |mysql> select CURTIME();                                                              |
|    |-> '23:50:26'                                                                         |
|    |mysql> select CURTIME() + 0;                                                          |
|    |-> 235026                                                                             |
|    |•  NOW()                                                                              |
|    |•  SYSDATE()                                                                          |
|    |•  CURRENT_TIMESTAMP Retourne la date et l'heure du jour, au format 'YYYY-MM-DD       |
|    |HH:MM:SS' or YYYYMMDDHHMMSS, suivant que la fonction est utilisée en contexte chaîne  |
|    |ou numérique                                                                          |
|    |                                                                                      |
|    |mysql> select NOW();                                                                  |
|    |-> '1997-12-15 23:50:26'                                                              |
|    |mysql> select NOW() + 0;                                                              |
|    |-> 19971215235026                                                                     |
|    |•  UNIX_TIMESTAMP()                                                                   |
|    |•  UNIX_TIMESTAMP(date) Utilisé sans argument, retourne un timestamp Unix (le nombre  |
|    |de secondes depuis '1970-01-01 00:00:00' GMT) . Utilisé avec un argument de type date,|
|    |il renvoie le timestamp Unix correspondant à cette date. DATE peut être aux formats   |
|    |chaîne DATE chaîne, DATETIME chaîne, TIMESTAMP, ou un nombre au format YYMMDD ou      |
|    |YYYYMMDD.                                                                             |
|    |                                                                                      |
|    |mysql> select UNIX_TIMESTAMP();                                                       |
|    |-> 882226357                                                                          |
|    |mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');                                  |
|    |-> 875996580                                                                          |
|    |Quand un UNIX_TIMESTAMP est affecté à une colonne de type TIMESTAMP, l'affectation    |
|    |sera directe, avec aucune conversion implicite.                                       |
|    |•  FROM_UNIXTIME(unix_timestamp) Retourne la représentation de l'argument             |
|    |unix_timestamp au format 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS suivant que la       |
|    |fonction est utilisée en contexte chaîne ou numérique                                 |
|    |                                                                                      |
|    |mysql> select FROM_UNIXTIME(875996580);                                               |
|    |-> '1997-10-04 22:23:00'                                                              |
|    |mysql> select FROM_UNIXTIME(875996580) + 0;                                           |
|    |-> 19971004222300                                                                     |
|    |•  FROM_UNIXTIME(unix_timestamp,format) Retourne la représentation de l'argument      |
|    |unix_timestamp au format format, suivant que la fonction est utilisée en contexte     |
|    |chaîne ou numérique. Le format est spécifié comme pour la fonction the DATE_FORMAT(). |
|    |                                                                                      |
|    |mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),                                         |
|    |'%Y %D %M %h:%i:%s %x');                                                              |
|    |-> '1997 23rd December 03:43:30 x'                                                    |
|    |•  SEC_TO_TIME(seconds) Converti l'argument seconds en heures, minutes et secondes, au|
|    |format 'HH:MM:SS' or HHMMSS, suivant que la fonction est utilisée en contexte chaîne  |
|    |ou numérique                                                                          |
|    |                                                                                      |
|    |mysql> select SEC_TO_TIME(2378);                                                      |
|    |-> '00:39:38'                                                                         |
|    |mysql> select SEC_TO_TIME(2378) + 0;                                                  |
|    |-> 3938                                                                               |
|    |•  TIME_TO_SEC(time) Retourne l'argument time, converti en secondes.                  |
|    |                                                                                      |
|    |mysql> select TIME_TO_SEC('22:23:00');                                                |
|    |-> 80580                                                                              |
|    |mysql> select TIME_TO_SEC('00:39:38');                                                |
|    |-> 2378                                                                               |
|    |7.3.12 Fonctions diverses                                                             |
|    |•  DATABASE() Retourne le nom de la base de données courante                          |
|    |                                                                                      |
|    |mysql> select DATABASE();                                                             |
|    |-> 'test'                                                                             |
|    |S'il n'y a pas de base de données courante, DATABASE() retourne une chaîne vide.      |
|    |•  USER()                                                                             |
|    |•  SYSTEM_USER()                                                                      |
|    |•  SESSION_USER() Retourne le nom de l'utilisateur MySQL courant.                     |
|    |                                                                                      |
|    |mysql> select USER();                                                                 |
|    |-> 'davida@localhost'                                                                 |
|    |Avec MySQL 3.22.11 ou plus récent, le nom de l'utilisateur courant contient le nom du |
|    |de l'hôte client. On peut alors en extraire le nom du User.                           |
|    |                                                                                      |
|    |mysql> select left(USER(),instr(USER(),"@")-1);                                       |
|    |-> 'davida'                                                                           |
|    |•  PASSWORD(str) Calcule un mot de passe à partir du texte de str. C'est une fonction |
|    |d'encryption utilisée par MySQL pour stocker les mots de passes dans la colonne       |
|    |Password, de la table des droits des utilisateurs.                                    |
|    |                                                                                      |
|    |mysql> select PASSWORD('badpwd');                                                     |
|    |-> '7f84554057dd964b'                                                                 |
|    |Le cryptage de PASSWORD() n'est pas reversible. PASSWORD() effectue un cryptage       |
|    |différent de celui d'Unix. Il ne faut pas croire que si le mot de passe de MySQL et   |
|    |d'Unix sont les mêmes, alors les deux valeurs cryptées seront les mêmes. Voir         |
|    |ENCRYPT().                                                                            |
|    |•  ENCRYPT(str[,salt]) Crypte la chaîne str en utilisant le cryptage d'Unix(          |
|    |crypt())l. Le grain de sel est une chaîne avec deux caractères.                       |
|    |                                                                                      |
|    |mysql> select ENCRYPT("hello");                                                       |
|    |-> 'VxuFAJXVARROc'                                                                    |
|    |Si la commande crypt() n'est pas disponible sur votre système, ENCRYPT()retournera    |
|    |NULL. ENCRYPT() n'utilise que les 8 premiers caractères de la chaîne, sur certains    |
|    |systèmes. Cela dépendra du comportement de l'appel système : crypt().                 |
|    |•  ENCODE(str,pass_str) Crypte la chaîne str en utilisant de mot de passe pass_str .  |
|    |Pour décrypter le résultat, il faut utiliser DECODE(). Le résultat est une chaîne     |
|    |binaire. Pour l'enregistrer, il faut l'affecter à une colonne de type BLOB .          |
|    |•  DECODE(crypt_str,pass_str) Décrypte la chaîne cryptée crypt_str, en utilisant le   |
|    |mot de passe pass_str . crypt_str doit être une chaîne retournée par ENCODE().        |
|    |•  MD5(string) Calcule la somme de vérification MD5 de ma chaîne. La valeur retournée |
|    |est un nombre hexadécimal de 32 bits, utilisé comme clé.                              |
|    |                                                                                      |
|    |mysql> select MD5("testing")                                                          |
|    |-> 'ae2b1fca515949e5d54fb22b8ed95575'                                                 |
|    |Cette fonction est issue de "RSA Data Security, Inc. MD5 Message-Digest Algorithm".   |
|    |•  LAST_INSERT_ID([expression ]) Retourne la dernière valeur générée automatiquement  |
|    |lors de la mise à jour d'une colonne de type AUTO_INCREMENT Voir Section              |
|    |mysql_insert_id.                                                                      |
|    |                                                                                      |
|    |mysql> select LAST_INSERT_ID();                                                       |
|    |-> 195                                                                                |
|    |Le dernier ID généré est conservé par le serveur, sur la base d'un par connexion. Il  |
|    |ne sera pas changé par un autre client. Il ne sera même pas changé par la mise à jour |
|    |d'une colonne de type AUTO_INCREMENT. Si expression est donné comme argument à        |
|    |LAST_INSERT_ID() dans une clause , alors la valeur de l'argument est retournée, en    |
|    |tant que LAST_INSERT_ID(). Cela peut être utile pour simuler des séquences. Par       |
|    |exemple :                                                                             |
|    |•  Création d'une table :                                                             |
|    |                                                                                      |
|    |mysql> create table sequence (id int not null);                                       |
|    |mysql> insert into sequence values (0);                                               |
|    |Alors la table peut être utilisée pour générer une séquence de nombre comme ceci :    |
|    |                                                                                      |
|    |mysql> update sequence set id=LAST_INSERT_ID(id+1);                                   |
|    |Il est possible de générer des séquences sans appeler LAST_INSERT_ID(), mais l'interêt|
|    |de cette fonction et que l'ID est conservé par le serveur en tant que dernière valeur |
|    |générée. Il est ainsi possible d'obtenir un nouvel ID comme lors de la lecture de     |
|    |n'importe quelle colonne de type AUTO_INCREMENT. Par exemple, LAST_INSERT_ID() (sans  |
|    |argument) retournera un nouvel ID . La méthode C API mysql_insert_id() peut aussi être|
|    |utilisée pour obtenir une telle valeur.                                               |
|    |•  FORMAT(X,D) Met le nombre X au format'#,###,###.##' avec D décimales. Si D vaut 0, |
|    |le résultat n'aura ni décimales, ni virgule.                                          |
|    |                                                                                      |
|    |mysql> select FORMAT(12332.1234, 2);                                                  |
|    |-> '12,332.12'                                                                        |
|    |mysql> select FORMAT(12332.1,4);                                                      |
|    |-> '12,332.1000'                                                                      |
|    |mysql> select FORMAT(12332.2,0);                                                      |
|    |-> '12,332'                                                                           |
|    |•  VERSION() Retourne la version du serveur MySQL .                                   |
|    |                                                                                      |
|    |mysql> select VERSION();                                                              |
|    |-> '3.22.19b-log'                                                                     |
|    |•  GET_LOCK(str,timeout) Essaie d'obtenir le verrous nommé str , avec un timeout de   |
|    |timeout secondes. Retourne 1 si le verrous a pu être obtenu, 0 en cas d'échec, ou si  |
|    |une erreur est survenue (comme par exemple, plus de mémoire disponible, ou le thread a|
|    |été tué par l'administrateur). Un verrou est libéré avec la fonction RELEASE_LOCK(),  |
|    |avec l'exécution de la fonction GET_LOCK() ou la mort du thread courant. Cette        |
|    |fonction peut être utilisée pour implémenter des verrous d'applications, ou simuler   |
|    |des verrous sur les enregistrements.                                                  |
|    |                                                                                      |
|    |mysql> select GET_LOCK("lock1",10);                                                   |
|    |-> 1                                                                                  |
|    |mysql> select GET_LOCK("lock2",10);                                                   |
|    |-> 1                                                                                  |
|    |mysql> select RELEASE_LOCK("lock2");                                                  |
|    |-> 1                                                                                  |
|    |mysql> select RELEASE_LOCK("lock1");                                                  |
|    |-> NULL                                                                               |
|    |Il faut noter que le deuxième appel à RELEASE_LOCK()retourne NULL car le verrou       |
|    |"lock1" a été automatiquement libéré par le deuxième appel à GET_LOCK().              |
|    |•  RELEASE_LOCK(str) Libère le verrous nommé str, obtenu par l'appel de GET_LOCK() .  |
|    |Retourne 1 si le verrous a bien été libéré, et 0 si il n'était pas mis par ce thread  |
|    |(dans ce cas, il reste verrouillé), et si ce verrous n'existe pas. Le verrous n'existe|
|    |pas tant qu'il n'a pas été créer par GET_LOCK() ou si il a déjà été libéré.           |
|    |•  BENCHMARK(count,expression ) La fonction de BENCHMARK exécute l'expression         |
|    |expression count fois. Cela permet de mesurer le temps que MySQL met à exécuter       |
|    |l'expression. Le résultat est toujours 0. Le temps mis pour l'exécution de la commande|
|    |est disponible sur l'affichage du client MySQL.                                       |
|    |                                                                                      |
|    |mysql> select BENCHMARK(1000000,encode("hello","goodbye"));                           |
|    |+----------------------------------------------+                                      |
|    || BENCHMARK(1000000,encode("bonjour","ca va")) |                                      |
|    |+----------------------------------------------+                                      |
|    ||                                            0 |                                      |
|    |+----------------------------------------------+                                      |
|    |1 row in set (4.74 sec)                                                               |
|    |Le temps affiché sur le client est le temps entre le début et la fin de l'exécution,  |
|    |et non pas le temps de travail du processeur. Il peut être nécessaire d'éxécuter      |
|    |plusieurs fois la commande, pour prendre en compte la charge de la machine.           |
|    |7.3.13 Fonctions à utiliser dans les clauses GROUP BY                                 |
|    |L'utilisation d'une fonction de regroupement dans une commande qui ne contient pas la |
|    |clause GROUP BY est équivalent à regrouper toutes les lignes.                         |
|    |•  COUNT(expression ) Retourne le nombre de lignes non-NULL obtenue par une commande  |
|    |SELECT.                                                                               |
|    |                                                                                      |
|    |mysql> select student.student_name,COUNT(*)                                           |
|    |from student,course                                                                   |
|    |where student.student_id=course.student_id                                            |
|    |GROUP BY student_name;                                                                |
|    |COUNT(*) est optimisé pour compter très rapidement les lignes obtenues par un SELECT  |
|    |sur une seule table, sans qu'aucune autre colonne ne soit demandée, et sans clause    |
|    |WHERE . Par exemple :                                                                 |
|    |                                                                                      |
|    |mysql> select COUNT(*) from student;                                                  |
|    |•  COUNT(DISTINCT expression ,[expression ...]) Retourne le nombre de ligne           |
|    |distinctes.                                                                           |
|    |                                                                                      |
|    |mysql> select COUNT(DISTINCT results) from student;                                   |
|    |Avec MySQL il est possible d'obtenir le nombre de combinaison d'expressions distinctes|
|    |en donnant une liste d'expression. E, ANSI SQL, il aurait fallu concaténer les        |
|    |expressions avec CODE(DISTINCT ..).                                                   |
|    |•  AVG(expression ) Retourne la moyenne des valeurs de expression .                   |
|    |                                                                                      |
|    |mysql> select student_name, AVG(test_score)                                           |
|    |from student                                                                          |
|    |GROUP BY student_name;                                                                |
|    |•  MIN(expression )                                                                   |
|    |•  MAX(expression ) Retourne le minimum ou le maximum de expression . MIN() et MAX()  |
|    |peuvent travailler avec des chaînes. Dans ce cas, il retourne la chaîne minimum       |
|    |maximum .                                                                             |
|    |                                                                                      |
|    |mysql> select student_name, MIN(test_score), MAX(test_score)                          |
|    |from student                                                                          |
|    |GROUP BY student_name;                                                                |
|    |•  SUM(expression ) Retourne la somme de expression . Si l'ensemble n'a aucune ligne, |
|    |le résultat est NULL!                                                                 |
|    |•  STD(expression )                                                                   |
|    |•  STDDEV(expression ) Retourne la déviation standard de expression . C'est une       |
|    |extension à la norme ANSI SQL. La fonction STDDEV() est fourni pour assurer la        |
|    |comptabilité avec les bases Oracle.                                                   |
|    |•  BIT_OR(expression ) Retourne le OU logique bit-à-bit, effectué sur expression . Ce |
|    |calcul est fait sur 64 bits (précision de BIGINT).                                    |
|    |•  BIT_AND(expression ) Retourne le ET logique bit-à-bit, effectué sur expression . Ce|
|    |calcul est fait sur 64 bits (précision de BIGINT).                                    |
|    |MySQL permet une utilisation étendue de GROUP BY. Il est possible de faire des calculs|
|    |sur des colonnes dans le SELECT même si elles n'apparaissent pas dans le GROUP BY .   |
|    |Cela est possible pour n'importe quelle valeur de ce groupe. Cela permet de gagner en |
|    |performance en évitant de faire des regroupements ou des tris sur des valeurs         |
|    |inutiles. Par exemple, il n'y a pas besoin de faire un regroupement avec customer.name|
|    |dans la requête suivante :                                                            |
|    |                                                                                      |
|    |mysql> select order.custid,customer.name,max(payments)                                |
|    |from order,customer                                                                   |
|    |where order.custid = customer.custid                                                  |
|    |GROUP BY order.custid;                                                                |
|    |La norme ANSI SQL impose d'ajouter customer.name dans la clause GROUP BY . Avec MySQL,|
|    |c'est redondant.                                                                      |
|    |Il ne faut pas utiliser cette particularité si les noms de colonnes ne sont pas unique|
|    |dans le groupe courant.                                                               |
|    |Dans certains cas, il est possible d'utiliser MIN() et MAX() pour obtenir la valeur   |
|    |d'une colonne spécifique, même si elle n'est pas unique. Par exemple, cette requête   |
|    |retourne la valeur de column, de la ligne qui contient la colonne sort la plus courte.|
|    |                                                                                      |
|    |                                                                                      |
|    |substr(MIN(concat(sort,space(6-longueur(sort)),column),7,longueur(column)))           |
|    |Il faut noter que avec MySQL 3.22 (ou avant), ou en suivant la norme ANSI SQL, il ne  |
|    |faut pas utiliser d'expressions dans les clauses GROUP BY ou ORDER BY. Il faut alors  |
|    |contourner la difficulté en utilisant un alias.                                       |
|    |                                                                                      |
|    |mysql> SELECT id,FLOOR(value/100) AS val FROM Nom_table                               |
|    |GROUP BY id,val ORDER BY val;                                                         |
|    |Avec MySQL 3.23, on peut écrire :                                                     |
|    |                                                                                      |
|    |mysql> SELECT id,FLOOR(value/100) FROM Nom_table ORDER BY RAND();                     |
|    |7.4 CREATE DATABASE                                                                   |
|    |                                                                                      |
|    |CREATE DATABASE nom_base_de_donnees                                                   |
|    |CREATE DATABASE Nom_bdd                                                               |
|    |CREATE DATABASE crée une base de donnée avec le nom Nom_bdd. Les règles qui régissent |
|    |les nom de base de données sont détaillées dans la section 7.1.5 Noms de base de      |
|    |données, table, index, column et alias. MySQL retourne une erreur si la base de       |
|    |données existe déjà. Avec MySQL, les bases sont représentées sous la forme de dossiers|
|    |qui contiendront des fichiers, qui représenteront les tables. Etant donné qu'à la     |
|    |création d'une base, cette dernière est vide, CREATE DATABASE se contente de créer un |
|    |dossier dans le dossier données de MySQL. Il est aussi possible de créer des bases    |
|    |avec la méthode mysqladmin. 12.1 Présentation des différents programmes MySQL.        |
|    |7.5 DROP DATABASE                                                                     |
|    |                                                                                      |
|    |DROP DATABASE [IF EXISTS] Nom_bdd                                                     |
|    |DROP DATABASE efface toutes les tables de la base , et efface aussi la base, i.e. le  |
|    |dossier. Il faut être TRES prudent avec cette commande.                               |
|    |DROP DATABASE retourne le nombre de fichiers qui ont été effacés. Normalement, ce     |
|    |nombre correspond à trois fois le nombre de table, étant donné que chaque table a     |
|    |trois fichier, un fichier ``.ISD',' un fichier ``.ISM'' et un fichier ``.frm''.       |
|    |MySQL 3.22 ou plus récent autorise l'utilisation du mot clé IF NOT EXISTS, qui ne     |
|    |retourne pas d'erreur si la base à effacer n'existe pas.                              |
|    |Il est aussi possible d'effacer des bases avec la méthode mysqladmin. 12.1            |
|    |Présentation des différents programmes MySQL.                                         |
|    |7.6 CREATE TABLE                                                                      |
|    |                                                                                      |
|    |CREATE [TEMPORARY] TABLE [IF NOT EXISTS] Nom_table (create_definition,...)            |
|    |[options_de_table] [commande_de_selection]                                            |
|    |                                                                                      |
|    |create_definition:                                                                    |
|    |Nom_col type [NOT NULL | NULL] [DEFAULT valeur_par_defaut] [AUTO_INCREMENT]           |
|    |[PRIMARY KEY] [reference_definition]                                                  |
|    |ou    PRIMARY KEY (index_Nom_col,...)                                                 |
|    |ou    KEY [Nom_index] KEY(index_Nom_col,...)                                          |
|    |ou    INDEX [Nom_index] (index_Nom_col,...)                                           |
|    |ou    UNIQUE [INDEX] [Nom_index] (index_Nom_col,...)                                  |
|    |ou    [CONSTRAINT symbole] FOREIGN KEY Nom_index(index_Nom_col,...)                   |
|    |[reference_definition]                                                                |
|    |ou    CHECK (expression )                                                             |
|    |                                                                                      |
|    |type:                                                                                 |
|    |TINYINT[(longueur)] [UNSIGNED] [ZEROFILL]                                             |
|    |ou    SMALLINT[(longueur)] [UNSIGNED] [ZEROFILL]                                      |
|    |ou    MEDIUMINT[(longueur)] [UNSIGNED] [ZEROFILL]                                     |
|    |ou    INT[(longueur)] [UNSIGNED] [ZEROFILL]                                           |
|    |ou    INTEGER[(longueur)] [UNSIGNED] [ZEROFILL]                                       |
|    |ou    BIGINT[(longueur)] [UNSIGNED] [ZEROFILL]                                        |
|    |ou    REAL[(longueur,décimales)] [UNSIGNED] [ZEROFILL]                                |
|    |ou    DOUBLE[(longueur,décimales)] [UNSIGNED] [ZEROFILL]                              |
|    |ou    FLOAT[(longueur,décimales)] [UNSIGNED] [ZEROFILL]                               |
|    |ou    DECIMAL(longueur,décimales) [UNSIGNED] [ZEROFILL]                               |
|    |ou    NUMERIC(longueur,décimales) [UNSIGNED] [ZEROFILL]                               |
|    |ou    CHAR(longueur) [BINARY]                                                         |
|    |ou    VARCHAR(longueur) [BINARY]                                                      |
|    |ou    DATE                                                                            |
|    |ou    TIME                                                                            |
|    |ou    TIMESTAMP                                                                       |
|    |ou    DATETIME                                                                        |
|    |ou    TINYBLOB                                                                        |
|    |ou    BLOB                                                                            |
|    |ou    MEDIUMBLOB                                                                      |
|    |ou    LONGBLOB                                                                        |
|    |ou    TINYTEXT                                                                        |
|    |ou    TEXT                                                                            |
|    |ou    MEDIUMTEXT                                                                      |
|    |ou    LONGTEXT                                                                        |
|    |ou    ENUM(value1,value2,value3,...)                                                  |
|    |ou    SET(value1,value2,value3,...)                                                   |
|    |                                                                                      |
|    |index_Nom_col:                                                                        |
|    |Nom_col [(longueur)]                                                                  |
|    |                                                                                      |
|    |reference_definition:                                                                 |
|    |REFERENCES Nom_table [(index_Nom_col,...)]                                            |
|    |[MATCH FULL | MATCH PARTIAL]                                                          |
|    |[ON DELETE reference_option]                                                          |
|    |[ON UPDATE reference_option]                                                          |
|    |                                                                                      |
|    |reference_option:                                                                     |
|    |RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT                               |
|    |                                                                                      |
|    |options_de_table:                                                                     |
|    |type = [ISAM | MYISAM | HEAP]                                                         |
|    |                                                                                      |
|    |ouauto_increment = #                                                                  |
|    |ouavg_row_longueur = #                                                                |
|    |ouchecksum = [0 | 1]                                                                  |
|    |oucomment = "string"                                                                  |
|    |oulignes_max= #                                                                       |
|    |oulignes_min = #                                                                      |
|    |oupack_keys = [0 | 1]                                                                 |
|    |oupassword= "string"                                                                  |
|    |commande_de_selection:                                                                |
|    |[ | IGNORE | REPLACE] SELECT ...  (Un select valide)                                  |
|    |CREATE TABLE crée une table, de nom Nom_table, dans la base de donnés courante. Les   |
|    |règles qui régissent les nom de table sont détaillées dans 7.1.5 Noms de base de      |
|    |données, table, index, column et alias. MySQL retourne une erreur si il n'y a pas de  |
|    |base de données courante, ou la table existe déjà.                                    |
|    |Avec MySQL 3.22 ou plus récent, on peut se référer à la table en utilisant la         |
|    |structure Nom_bdd.Nom_table. Ceci fonctionne, qu'il y ait une base de données courante|
|    |ou pas.                                                                               |
|    |MySQL 3.23 autorise l'utilisation du mot clé TEMPORARY lors de la création de table.  |
|    |Une table temporaire sera automatiquement effacée lorsque la connexion sera terminée. |
|    |Cela permet à deux connexions différents d'utiliser le même nom de table temporaire,  |
|    |sans conflit l'un avec l'autre, ou avec une table existante (la table permanente est  |
|    |cachée jusqu'à ce que la table temporaire soit effacée).                              |
|    |MySQL 3.22 ou plus récent autorise l'utilisation du mot clé IF NOT EXISTS, qui ne     |
|    |retourne pas d'erreur si la table à créer existe déjà.                                |
|    |Chaque table est representée par un ou plusieurs fichiers dans le dossier de la bas e |
|    |de données. Dans le cas ou la table est de type ISAM, il y aura :                     |
|    |Pour plus d'information sur les propriétés des différents type de colonne, 7.2 Types  |
|    |de colonnes.                                                                          |
|    |Si ni NULL ni NOT NULL n'a été précisé, alors la colonne est considéré comme de type  |
|    |NULL.                                                                                 |
|    |Une colonne de type entier peut avoir l'attribut AUTO_INCREMENT. A chaque insertion de|
|    |la valeur ou de 0 dans une colonne de type AUTO_INCREMENT, la valeur de la colonne est|
|    |mise à value+1, avec value qui est la plus grande valeur dans la colonne de la table  |
|    |courante. AUTO_INCREMENT commence à 1. Si la ligne contenant la plus grande valeur de |
|    |la colonne est effacée, cette valeur sera réutilisée. Si toutes les lignes de la table|
|    |sont effacée, AUTO_INCREMENT recommence à 1. Il ne peux y avoir qu'une seule colonne  |
|    |de type AUTO_INCREMENT par table, et cette colonne doit être indexée. Par souci de    |
|    |compatibilité avec ODBC, il est possible d'accéder à la dernière ligne insérée avec la|
|    |requête suivante :                                                                    |
|    |                                                                                      |
|    |SELECT * FROM Nom_table WHERE auto_col IS NULL                                        |
|    |Les valeurs NULL sont gérées de manière différentes pour les colonnes de type         |
|    |TIMESTAMP. Il n'est pas possible de stocker la valeur NULL dans une colonne de type   |
|    |TIMESTAMP, alors cette affectation conduit à affecter la date et l'heure courante à la|
|    |place. A cause de ce comportement, les attributs NULL et NOT NULL ne s'appliquent pas,|
|    |et sont ignorées. D'un autre coté, afin de rendre MySQL plus simple à utiliser, le    |
|    |serveur autorise l'affectation de NULL aux colonnes de type TIMESTAMP (ce qui est     |
|    |vrai), même si les colonnes de type TIMESTAMP ne contiendront jamais réellement la    |
|    |valeur NULL. Cette information est accessible en utilisant la commande DESCRIBE       |
|    |Nom_table qui détaille les colonnes de la table. Il est bon de rappeler que la valeur |
|    |0 est une valeur valide de TIMESTAMP.                                                 |
|    |Si aucune valeur par défaut n'est précisé avec l'attribut DEFAULT, MySQL en assignera |
|    |automatiquement une. Si la colonne peut prendre la valeur NULL, alors MySQL utilisera |
|    |cette valeur par défaut. Sinon, son comportement dépendra du type de colonne :        |
|    |Pour les types numériques autres que ceux ayant l'attribut AUTO_INCREMENT , la valeur |
|    |par défaut est 0 . Pour les colonnes ayant l'attribut AUTO_INCREMENT, la valeur par   |
|    |défaut est la prochaine valeur de la séquence.                                        |
|    |Pour les types date et heures, excepté TIMESTAMP, la valeur par défaut est le ``zéro''|
|    |. Pour la première colonne de type TIMESTAMP, la valeur par défaut est la date et     |
|    |l'heure courante. 7.2.6 Types date et heure.                                          |
|    |Pour les types chaînes, autre que ENUM, la valeur par défaut est la chaîne vide. Pour |
|    |le type ENUM, la valeur par défaut est la première valeur de l'énumération.           |
|    |KEY est un synonyme pour INDEX.                                                       |
|    |Avec MySQL, l'attribut UNIQUE force la valeur à toujours prendre une valeur distincte.|
|    |Une erreur surviendra lors de l'insertion d'une ligne qui doublera une ligne déjà     |
|    |existante.                                                                            |
|    |Avec MySQL, l'attribut PRIMARY KEY est identique à l'attribut KEY qui porterait le nom|
|    |de PRIMARY Une table ne peut avoir qu'une seule colonne avec l'attribut table PRIMARY |
|    |KEY. Si aucune colonne n'a de PRIMARY KEY et qu'une application requiert la colonne de|
|    |PRIMARY KEY, MySQL retournera la première colonne ayant l'attribut UNIQUE.            |
|    |Une PRIMARY KEY peut être un index multi colonne. Mais il n'est pas possible de créer |
|    |un index multi colonne qui aurait l'attribut PRIMARY KEY. Pour cela, il faut utiliser |
|    |la fonction PRIMARY KEY(index_Nom_col, ...) , sous peine de ne voir que la première   |
|    |colonne porter l'attribut PRIMARY KEY.                                                |
|    |Si aucun nom n'est affecté à un index, un nom sera automatiquement généré et assigné. |
|    |Ce nom sera constitué du nom de la première colonne, avec un suffixe optionnel,(_2,   |
|    |_3, ...), pour l rendre unique. La liste des noms d'index est accessible avec la      |
|    |requête : SHOW INDEX FROM Nom_table.                                                  |
|    |Seule les tables de type MyISAM acceptent les index sur les colonnes qui contiennent  |
|    |la valeur NULL. Dans les autres cas, il faut absolument déclarer la colonne de type   |
|    |NOT NULL pour ne pas générer une erreur.                                              |
|    |Avec la syntaxe Nom_col(longueur), il est possible de spécifier un index qui utilise  |
|    |seulement une partie de la colonne de type CHAR or VARCHAR. Cela rend l'index         |
|    |nettement plus petit et plus efficace. Indexes.                                       |
|    |Seules les tables de type MyISAM acceptent d'indexer les colonnes de type BLOB et TEXT|
|    |. mettre un index sur une telle colonne impose de préciser la longueur de la colonne  |
|    |dans l'index.                                                                         |
|    |                                                                                      |
|    |CREATE TABLE test (blob_col BLOB, index(blob_col(10)));                               |
|    |Lors de l'utilisation des clauses ORDER BY ou GROUP BY avec de colonnes de type TEXT  |
|    |ou BLOB, seuls les max_sort_longueur premiers octets sont pris en compte. BLOB.       |
|    |Les attributs FOREIGN KEY, CHECK et REFERENCES ne font en réalité rien de spécial. Ils|
|    |sont uniquement fournis pour assurer la compatibilité et la portabilité de programme  |
|    |SQL et de les faire tourner avec MySQL.                                               |
|    |Les colonnes de type prennent un bit de plus, arrondi à l'octet le plus proche.       |
|    |La taille maximale d'un enregistrement peut être obtenue avec la requête suivante :   |
|    |                                                                                      |
|    |row longueur = 1                                                                      |
|    |+ (sum of column longueurs)                                                           |
|    |+ (number of NULL columns + 7)/8                                                      |
|    |+ (number of variable-longueur columns)                                               |
|    |Les options options_de_table et SELECT ne sont disponibles qu'à partir de MySQL 3.23. |
|    |Les différents types de tables sont :                                                 |
|    |Les options de table sont utilisées pour optimiser la gestion de la table. Dans la    |
|    |plus part des cas, ces options peuvent être ignorées. Ces options fonctionnent pour   |
|    |toutes les types de table, sauf indication contraire.                                 |
|    |Lors de l'utilisation d'une tape de type MyISAM table, MySQL utilise le produit max*  |
|    |avg_row_longueur pour connaître la taille maximale de la table. Par défaut, la taille |
|    |maximale de la table est 4Go (4 Giga octets) (ou 2Go, si le système ne les supporte   |
|    |pas.                                                                                  |
|    |Si un CREATE STATEMENT est spécifié après SELECT, MySQL va créer de nouveaux champs   |
|    |pour chacun des éléments dans le SELECT . Par exemple                                 |
|    |                                                                                      |
|    |mysql> CREATE TABLE test (a int not null auto_increment, primary key (a), key(b))     |
|    |TYPE=HEAP SELECT b,c from test2;                                                      |
|    |Cette requête va créer une table de type HEAP table avec 3 colonnes. Cette table sera |
|    |automatiquement effacée si une erreur survient lors de la copie des données dans ma   |
|    |table.                                                                                |
|    |7.6.1 Modifications automatiques de type de colonne                                   |
|    |Dans certains cas, MySQL spontanément les spécifications d'une colonne lors d'une     |
|    |commande de CREATE TABLE (Cela peut aussi intervenir lors d'une commande with ALTER   |
|    |TABLE.)                                                                               |
|    |Les colonnes de type VARCHAR d'une longueur de moins de 4 caractères sont changées en |
|    |CHAR.                                                                                 |
|    |Si l'une des colonne de la table a une longueur variable, alors la ligne complète a   |
|    |aussi une longueur variable. Par conséquent, si la table contient une colonne de      |
|    |longueur variable(VARCHAR, TEXT or BLOB), toutes les colonnes de type CHAR et de      |
|    |longueur supérieur à 3 caractères sont changées en colonne de type VARCHAR .Cela ne   |
|    |change en rien l'utilisation de ces colonnes, cela modifie simplement la façon dont   |
|    |les colonnes sont stockées. MySQL effectue cette conversion car cela économise de la  |
|    |place, et rend les opérations sur la table plus rapides.                              |
|    |La taille d'affichage des colonnes de type TIMESTAMP doit être pair et compris dans   |
|    |l'intervalle de 2 à 14. En dehors de l'intervalle 2 à 14, la taille de l'affichage est|
|    |ramenée à 14. En cas de nombre impair, le nombre est arrondi au nombre pair           |
|    |directement supérieur.                                                                |
|    |Il est impossible d'enregistrer une valeur NULL dans une colonne de type TIMESTAMP,   |
|    |car une telle affectation revient à assigner la date et l'heure courante à la colonne.|
|    |De ce fait, les attributs NULL et NOT NULL ne s'appliquent pas aux colonnes de type   |
|    |TIMESTAMP, et sont ignorés. Lors d'une requête DESCRIBE Nom_table MySQL répondra      |
|    |toujours que la colonne accepte les valeurs de type NULL.                             |
|    |MySQL effectue la correspondance entre certains types utilisé par d'autres bases de   |
|    |données SQL vers des types MySQL. 7.2.11 Utiliser des types de colonnes d'autres bases|
|    |de données.                                                                           |
|    |Pour savoir si MySQL a modifié spontanément le type d'une colonne, il faut utiliser la|
|    |requête DESCRIBE Nom_table après la création ou la modification de la table.          |
|    |Certaines autres modifications de type peuvent intervenir lors de la compression de   |
|    |table avec la commande pack_isam. 10.17 Quel sont les différents formats de lignes?   |
|    |Quand utiliser VARCHAR/CHAR?.                                                         |
|    |7.7 ALTER TABLE                                                                       |
|    |                                                                                      |
|    |ALTER [IGNORE] TABLE Nom_table alter_spec [, alter_spec ...]                          |
|    |alter_specification:                                                                  |
|    |ADD [COLUMN] create_definition [FIRST | AFTER column_name ]                           |
|    |ou    ADD INDEX [Nom_index] (index_Nom_col,...)                                       |
|    |ou    ADD PRIMARY KEY (index_Nom_col,...)                                             |
|    |ou    ADD UNIQUE [Nom_index] (index_Nom_col,...)                                      |
|    |ou    ALTER [COLUMN] Nom_col {SET DEFAULT literal | DROP DEFAULT}                     |
|    |ou    CHANGE [COLUMN] old_Nom_col create_definition                                   |
|    |ou    MODIFY [COLUMN] create_definition                                               |
|    |ou    DROP [COLUMN] Nom_col                                                           |
|    |ou    DROP PRIMARY KEY                                                                |
|    |ou    DROP INDEX key_name                                                             |
|    |ou    RENAME [AS] new_Nom_table                                                       |
|    |ou    table_option                                                                    |
|    |ALTER TABLE modifie la structure d'une table existante. Par exemple, il est possible  |
|    |d'ajouter ou d'effacer des colonnes, de créer et détruire des index, de changer le    |
|    |type d'une colonne ou de la renommer, voire même de renommer la table elle-même. Il   |
|    |est aussi possible de changer le commentaire de la table et son type. Voir CREATE     |
|    |TABLE.                                                                                |
|    |Si, lors d'une modification de type de colonne, la commande DESCRIBE Nom_table indique|
|    |que la colonne n'a pas changé de type, il est possible que MySQL ait ignoré la        |
|    |modification pour une des raisons décrites dans 7.6.1 Modifications automatiques de   |
|    |type de colonne. Par exemple, si il existe plusieurs colonne de type de longueur      |
|    |variable, rien de sert de tenter de forcer une colonne du type VARCHAR à CHAR.        |
|    |ALTER TABLE fonctionne en effectuant une copie temporaire de la table originale. La   |
|    |modification est effectuée sur la copie, puis l'originale est remplacée par la copie  |
|    |modifiée. Toutes les mises à jours sont automatiquement appelé, et sont faites dans un|
|    |mode sans erreur. Pendant la modification, la table originale est toujours accessible |
|    |en lecture par les autres clients. Les mises à jour et les écritures sont reportées   |
|    |jusqu'à la fin de la modification.                                                    |
|    |Pour pouvoir utiliser la commande ALTER TABLE, il faut avoir les droits pour select,  |
|    |insert, delete, update, create et drop sur la table.                                  |
|    |IGNORE est une extension MySQL de la norme ANSI SQL92. Il permet de contrôler la façon|
|    |avec laquelle réagit si il trouve des doublons dans une colonne de clés uniques. Si   |
|    |n'est pas précisé, la copie est annulée à la première erreur, et la modification est  |
|    |annulée. Si est précisé, alors la première occurrence d'une clés en double sera       |
|    |utilisée, les autres occurrences étant ignorées et effacées.                          |
|    |Il est possible d'utiliser plusieurs clauses ADD, ALTER, DROP et CHANGE dans une      |
|    |commande ALTER TABLE. C'est une extension de MySQL à la norme ANSI SQL92 : cette      |
|    |dernière ne permet qu'une seule de ces clauses à chaque commande.                     |
|    |CHANGE Nom_col, DROP Nom_col et DROP INDEX sont des extensions de MySQL à la norme    |
|    |ANSI SQL92                                                                            |
|    |CHANGE Nom_col, DROP Nom_col et DROP INDEX sont des extensions de MySQL à la norme    |
|    |ANSI SQL92 .                                                                          |
|    |MODIFY est une extension Oracle à ALTER TABLE.                                        |
|    |L'option COLUMN est simplement de la décoration et peut être ignoré.                  |
|    |La commande '' ALTER TABLE Nom_table RENAME AS new_name '' sans aucune autre option,  |
|    |permet de renommer la table. MySQL va simplement renommer les fichiers correspondant à|
|    |la table Nom_table. Il n'y a pas de création de table temporaire.                     |
|    |La clause create_definition utilise la même syntaxe que les clauses ADD et CHANGE,    |
|    |ainsi que CREATE TABLE. Cette inclus le nom de la colonne, et pas seulement le type de|
|    |colonne. Voir CREATE TABLE.                                                           |
|    |La commande CHANGE old_Nom_col create_definition permet de changer le nom d'une       |
|    |colonne. Pour cela, il faut spécifier l'ancien et le nouveau nom de la colonne, ainsi |
|    |que le type courant de la colonne. Par exemple, pour renommer une colonne de type     |
|    |INTEGER de 'a' en 'b', la commande suivante est valable :                             |
|    |                                                                                      |
|    |mysql> ALTER TABLE t1 CHANGE a b INTEGER;                                             |
|    |Pour changer le type de la colonne mais pas son nom, la syntaxe de CHANGE requiert    |
|    |deux noms de colonnes, même si ils sont identiques. Par exemple :                     |
|    |                                                                                      |
|    |mysql> ALTER TABLE t1 CHANGE b b BIGINT NOT NULL;                                     |
|    |Cependant, à partir de MySQL 3.22.16a, il est possible d'utiliser la clause MODIFY    |
|    |pour changer le type de la colonne sans le renommer:                                  |
|    |                                                                                      |
|    |mysql> ALTER TABLE t1 MODIFY b BIGINT NOT NULL;                                       |
|    |Lors de l'utilisation de CHANGE ou MODIFY pour réduire la taille d'une colonne qui    |
|    |possède un index (par exemple, un index sur les 10 premiers caractères d'une colonne  |
|    |de type VARCHAR ), il est impossible de rendre la colonne plus petite que ne le       |
|    |requiert l'index.                                                                     |
|    |En changeant le type d'une colonne avec CHANGE ou MODIFY, MySQL essaie de convertir au|
|    |mieux les informations d'un type à l'autre.                                           |
|    |A partir de MySQL 3.22, il est possible d'utiliser FIRST ou ADD ... AFTER Nom_col pour|
|    |ajouter une colonne à une position donnée, dans une table. Par défaut, l'ajout de fait|
|    |après la dernière colonne.                                                            |
|    |ALTER COLUMN spécifie une nouvelle valeur par défaut, ou bien efface l'ancienne       |
|    |valeur. Si la valeur par défaut de la colonne est effacée, et que la colonne peut être|
|    |NULL, alors la nouvelle valeur par défaut est NULL.Si la colonne ne peut pas être     |
|    |NULL, alors MySQL assigne une valeur par défaut arbitraire, comme décrit dans le      |
|    |paragraphe CREATE TABLE.                                                              |
|    |DROP INDEX efface un index. C'est une extension de MySQL à la norme ANSI SQL92 .      |
|    |Lorsqu'une colonne est effacée d'une table, la colonne est aussi effacée de toutes les|
|    |index qui l'utilise. Si toutes les colonnes qui composent un index sont effacées,     |
|    |l'index disparaît aussi.                                                              |
|    |DROP PRIMARY KEY efface la colonne qui porte l'attribut PRIMARY KEY . Si une telle    |
|    |colonne n'existe pas, la première colonne de type UNIQUE est effacée à la place.      |
|    |(MySQL utilise la première colonne UNIQUE comme PRIMARY KEY si aucune PRIMARY KEY     |
|    |n'est spécifiée.)                                                                     |
|    |Avec l'API C mysql_info(), il est possible de savoir combien de ligne ont été copiée, |
|    |et (quand l'option IGNORE était mise), le nombre de lignes qui furent effacées, à     |
|    |cause de la duplication de clés.                                                      |
|    |                                                                                      |
|    |Les attributs FOREIGN KEY, CHECK et REFERENCES ne font en réalité rien de spécial. Ils|
|    |sont uniquement fournis pour assurer la compatibilité et la portabilité de programme  |
|    |SQL et de les faire tourner avec MySQL.                                               |
|    |Voici quelques exemples d'utilisation de la commande ALTER TABLE. On supposera que la |
|    |table t1, créée ci-dessous, existe :                                                  |
|    |                                                                                      |
|    |mysql> CREATE TABLE t1 (a INTEGER,b CHAR(10));                                        |
|    |Renomme la table de t1 et t2:                                                         |
|    |                                                                                      |
|    |mysql> ALTER TABLE t1 RENAME t2;                                                      |
|    |Change le type de la colonne a de INTEGER en TINYINT NOT NULL (mais ne change pas le  |
|    |nom), et change le type de la colonne b de CHAR(10) en CHAR(20) et renomme cette      |
|    |colonne en c.                                                                         |
|    |                                                                                      |
|    |mysql> ALTER TABLE t2 MODIFY a TINYINT NOT NULL, CHANGE b c CHAR(20);                 |
|    |Ajoute une nouvelle colonne d, de type TIMESTAMP.                                     |
|    |                                                                                      |
|    |mysql> ALTER TABLE t2 ADD d TIMESTAMP;                                                |
|    |Ajoute un index sur la colonne d, et fait de la colonne a une PRIMARY KEY             |
|    |                                                                                      |
|    |mysql> ALTER TABLE t2 ADD INDEX (d), ADD PRIMARY KEY (a);                             |
|    |Efface la colonne c:                                                                  |
|    |                                                                                      |
|    |mysql> ALTER TABLE t2 DROP COLUMN c;                                                  |
|    |Ajoute une nouvelle colonne de type AUTO_INCREMENT integer , nommée c:                |
|    |                                                                                      |
|    |mysql> ALTER TABLE t2 ADD c INT UNSIGNED NOT NULL AUTO_INCREMENT,                     |
|    |ADD INDEX (c);                                                                        |
|    |Il faut remarquer que la colonne c a été indexée, car les colonnes de type            |
|    |AUTO_INCREMENT doivent être indexée, ce qui implique c doit avoir l'attribut NOT NULL,|
|    |puisque les colonnes indexées ne peuvent pas avoir de valeur à NULL.                  |
|    |7.8 OPTIMIZE TABLE                                                                    |
|    |                                                                                      |
|    |OPTIMIZE TABLE Nom_table                                                              |
|    |OPTIMZE TABLE est à utiliser après avoir effacer de grandes parties d'une table, pour |
|    |après des modifications majeures sur une table à longueur de ligne variable. Les index|
|    |des lignes effacées sont conservés, et l'opération INSERT les réutilise, et écrase mes|
|    |anciennes lignes. La commande OPTIMIZE TABLE permet de récupérer l'espace inutilisé   |
|    |des tables.                                                                           |
|    |OPTIMIZE TABLE fonctionne en effectuant une copie temporaire de la table originale. La|
|    |modification est effectuée sur la copie, puis l'originale est remplacée par la copie  |
|    |modifiée. Toutes les mises à jours sont automatiquement appelé, et sont faites dans un|
|    |mode sans erreur. Pendant la modification, la table originale est toujours accessible |
|    |en lecture par les autres clients. Les mises à jour et les écritures sont reportées   |
|    |jusqu'à la fin de la modification.                                                    |
|    |7.9 DROP TABLE                                                                        |
|    |                                                                                      |
|    |DROP TABLE [IF EXISTS] Nom_table [, Nom_table,...]                                    |
|    |DROP TABLE efface une ou plusieurs tables. Toutes les données et le fichier de        |
|    |définition sont effacés. Cette commande est irréversible                              |
|    |MySQL 3.22 ou plus récent autorise l'utilisation du mot clé IF EXISTS, qui ne retourne|
|    |pas d'erreur si la table à effacer n'existe pas.                                      |
|    |7.10 DELETE                                                                           |
|    |                                                                                      |
|    |DELETE [LOW_PRIORITY] FROM Nom_table                                                  |
|    |[WHERE where_definition] [LIMIT rows]                                                 |
|    |DELETE efface les lignes de la table Nom_table qui satisfont les conditions données   |
|    |par where_definition, et retourne le nombre de ligne effacées.                        |
|    |Une commande DELETE sans clause WHERE s'applique à toutes les lignes, c'est à dire que|
|    |la table est vidée de toutes ses données (mais elle n'est pas effacée). MySQL recrée  |
|    |alors la table, mais vide, ce qui est nettement plus rapide que d'effacer les lignes  |
|    |unes à unes. Dans ce cas particulier, MySQL retourne 0 (. (MySQL ne peut pas connaître|
|    |le nombre de ligne de la table sans l'avoir ouverte, car la recréation est faite sans |
|    |accéder à la table), return the number of rows that were actually deleted, since the  |
|    |recreate is done without opening the data files). Tant que le fichier ``Nom_table.frm'|
|    |est valide, il est possible de recréer la table, même si le fichier de données est    |
|    |corrompu).'                                                                           |
|    |Pour obtenir le nombre de ligne effacées lors de l'effacement de la table, il est     |
|    |toujours possible de sacrifier la vitesse d'exécution, et d'utiliser la commande      |
|    |suivante :                                                                            |
|    |                                                                                      |
|    |mysql> DELETE FROM Nom_table WHERE 1>0;                                               |
|    |Cette requête est particulièrement LENTE, car l'effacement se fait ligne à ligne, à   |
|    |cause de la clause WHERE                                                              |
|    |L'option LOW_PRIORITY permet de reporter l'effacement jusqu'au moment ou il ne reste  |
|    |plus personne qui lise la table.                                                      |
|    |Les ligne effacées sont conservées dans une liste, et les insertions ultérieurs       |
|    |réutiliseront cette place. Pour forcer la récupération de cette place, il faut        |
|    |utiliser la commande OPTIMIZE TABLE ou bien l'utilitaire isamchk pour réorganiser les |
|    |tables. OPTIMIZE TABLE est plus simple, mais isamchk plus rapide. OPTIMIZE TABLE.     |
|    |L'option LIMIT, spécifique à MySQL, permet d'indiquer au serveur le nombre maximum de |
|    |ligne à effacer. Cela permet d'éviter qu'une commande DELETE ne prenne trop de temps. |
|    |Il suffit alors de répéter la commande jusqu'à ce qu'elle ait effacé moins de ligne   |
|    |que LIMIT.                                                                            |
|    |7.11 SELECT                                                                           |
|    |                                                                                      |
|    |SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [DISTINCT | DISTINCTROW | ALL]              |
|    |select_expression,...                                                                 |
|    |[INTO OUTFILE 'Nom_fichier' export_options]                                           |
|    |[FROM table_references                                                                |
|    |[WHERE where_definition]                                                              |
|    |[GROUP BY Nom_col,...]                                                                |
|    |[HAVING where_definition]                                                             |
|    |[ORDER BY {unsigned_integer | Nom_col | formula} [ASC | DESC] ,...]                   |
|    |[LIMIT [offset,] rows]                                                                |
|    |[PROCEDURE procedure_name] ]                                                          |
|    |SELECT est utilisé pour obtenir des lignes à partir d'une ou plusieurs tables.        |
|    |select_expression indique les colonnes à lire. SELECT peut aussi être utilisé pour    |
|    |exécuter des calculs sans rapport avec aucune table. Par exemple :                    |
|    |                                                                                      |
|    |mysql> SELECT 1 + 1;                                                                  |
|    |-> 2                                                                                  |
|    |Toutes les options doivent impérativement être dans l'ordre indiqué ci dessus. Par    |
|    |exemple, une clause HAVING doit être après GROUP BY et avant la clause ORDER BY .     |
|    |Une clause SELECT peut utiliser des alias, introduit par le mot clé AS. L'alias est   |
|    |utilisé comme un nom de colonne, et peut être repris dans une clause ORDER BY ou      |
|    |HAVING. Par exemple:                                                                  |
|    |                                                                                      |
|    |mysql> select concat(last_name,', ',first_name) AS full_name                          |
|    |from maTable ORDER BY full_name;                                                      |
|    |La clause FROM table_references indique les noms des tables qu'il faut interroger. Si |
|    |il y a plusieurs tables, il vaut mieux utiliser la clause join. JOIN.                 |
|    |Il est possible d'appeler une colonne sous les formes Nom_col, Nom_table.Nom_col or   |
|    |Nom_bdd.Nom_table.Nom_col. Il n'y a pas besoin de préciser les préfixes Nom_table ou  |
|    |Nom_bdd.Nom_table lors d'un SELECT à moins que les noms soient ambiguës. 7.1.5 Noms de|
|    |base de données, table, index, column et alias, pour des exemples sur les ambiguïtés  |
|    |qui peuvent apparaître.                                                               |
|    |Une référence sur une table peut être aliasée avec Nom_table [AS] Nom_alias.          |
|    |                                                                                      |
|    |mysql> select t1.name, t2.salary from employee AS t1, info AS t2                      |
|    |where t1.name = t2.name;                                                              |
|    |mysql> select t1.name, t2.salary from employee t1, info t2                            |
|    |where t1.name = t2.name;                                                              |
|    |Les colonnes demandées en sortie peuvent être utilisées dans les clauses ORDER BY et  |
|    |GROUP BY en utilisant leur nom, leurs alias ou leur positions. Les colonnes sont      |
|    |positionnées à partir de 1.                                                           |
|    |                                                                                      |
|    |mysql> select college, region, seed from tournament                                   |
|    |ORDER BY region, seed;                                                                |
|    |mysql> select college, region AS r, seed AS s from tournament                         |
|    |ORDER BY r, s;                                                                        |
|    |mysql> select college, region, seed from tournament                                   |
|    |ORDER BY 2, 3;                                                                        |
|    |Pour trier dans l'ordre descendant, il faut ajouter le mot clé DESC après le nom de la|
|    |colonne, dans la clause ORDER BY . Par défaut, l'ordre ascendant est utilisé, et peut |
|    |être explicitement demandé en utilisant le mot clé ASC                                |
|    |La clause HAVING peut faire référence à n'importe quelle colonne ou alias présent dans|
|    |select_expression. Cette clause est évaluée en dernier, juste avant que les lignes    |
|    |soient envoyées au client, sans aucune optimisation. Il ne faut pas utiliser HAVING là|
|    |WHERE où est plus efficace. Par exemple, il ne faut pas écrire :                      |
|    |                                                                                      |
|    |mysql> select Nom_col from Nom_table HAVING Nom_col > 0;                              |
|    |A la place, il vaut mieux écrire :                                                    |
|    |                                                                                      |
|    |mysql> select Nom_col from Nom_table WHERE Nom_col > 0;                               |
|    |A partir de MySQL 3.22.5, on peut écrire des requêtes telles que:                     |
|    |                                                                                      |
|    |mysql> select user,max(salary) from users                                             |
|    |group by user HAVING max(salary)>10;                                                  |
|    |Dans les versions anciennes de MySQL , il était possible d'écrire :                   |
|    |                                                                                      |
|    |mysql> select user,max(salary) AS sum from users                                      |
|    |group by user HAVING sum>10;                                                          |
|    |L'option STRAIGHT_JOIN force l'optimiseur à regrouper les tables dans l'ordre dans    |
|    |lequel elles sont spécifiées dans la FROM . Cela permet d'accélérer le traitement     |
|    |d'une requête. EXPLAIN.                                                               |
|    |L'option SQL_SMALL_RESULT peut être utilisé avec les clauses GROUP BY ou DISTINCT pour|
|    |indiquer à l'optimiseur que le résultat sera de petite taille. Dans ce cas, MySQL va  |
|    |utiliser des tables temporaires d'accès rapide, pour enregistrer les tables de        |
|    |résultat, plutot que de faire des tries. SQL_SMALL_RESULT est une extension MySQL de  |
|    |ANSI SQL92.                                                                           |
|    |L'option LIMIT peut être utilisée pour restreindre le nombre de lign retournée SELECT |
|    |. LIMIT a un ou deux arguments numériques.. Le premier indique l'index de la ligne de |
|    |début, et le deuxième indique le nombre de ligne à retourner. L'indexe de la ligne    |
|    |initiale est 0.                                                                       |
|    |                                                                                      |
|    |mysql> select * from table LIMIT 5,10;  # retourne les lignes 6-15                    |
|    |Si un seul argument est fourni à LIMIT, il indique le nombre de ligne à retourner.    |
|    |                                                                                      |
|    |mysql> select * from table LIMIT 5;     # retourne les 5 premiere lignes              |
|    |LIMIT n et LIMIT 0,n sont équivalents.                                                |
|    |La forme SELECT ... INTO OUTFILE 'Nom_fichier' de la syntaxe de SELECT écrit les      |
|    |lignes selectionnées dans un fichier. Les fichiers créés sont écrit sur le serveur, et|
|    |ne doit pas exister au moment de l'écriture (cela évite d'écraser le fichier          |
|    |/etc/passwd, par exemple). Il faut avoir les droits d'écriture. SELECT ... INTO       |
|    |OUTFILE est le contraire de la commande LOAD DATA INFILE; qui importe les lignes à    |
|    |partir d'un fichier. L'expression export_options est constituée des même champs FIELDS|
|    |et LINES que dans la commande LOAD DATA INFILE . section LOAD DATA. Dans le fichier   |
|    |texte résultant de la commande SELECT ... INTO OUTFILE , seuls, les caractères        |
|    |suivants sont précédé du caractère d'échappement, précisé avec ESCAPED BY:            |
|    |Le caractère ESCAPED BY                                                               |
|    |Le premier caractère dans la clause FIELDS TERMINATED BY                              |
|    |Le premier caractère dans la clause LINES TERMINATED BY                               |
|    |De plus, le caractère ASCII 0 est converti en ESCAPED BY suivi de 0 (ASCII 48). La    |
|    |raison de l'ajout du caractère d'échappement après les caractères FIELDS TERMINATED   |
|    |BY, ESCAPED BY ou LINES TERMINATED BY ,est que cela permet la relecture du fichier. Le|
|    |caractère ASCII 0 est échappé pour le rendre plus lisible par les éditeurs. Et comme  |
|    |le fichier résultant n'a pas à se conformer à la norme SQL, ce sont les seuls         |
|    |caractères à être échappés.                                                           |
|    |7.12 JOIN                                                                             |
|    |MySQL utilise les syntaxes suivantes pour les commandes de JOIN:                      |
|    |                                                                                      |
|    |table_reference, table_reference                                                      |
|    |table_reference [CROSS] JOIN table_reference                                          |
|    |table_reference INNER JOIN table_reference                                            |
|    |table_reference STRAIGHT_JOIN table_reference                                         |
|    |table_reference LEFT [OUTER] JOIN table_reference ON conditional_expression           |
|    |table_reference LEFT [OUTER] JOIN table_reference USING (column_list)                 |
|    |table_reference NATURAL LEFT [OUTER] JOIN table_reference                             |
|    |{ oj table_reference LEFT OUTER JOIN table_reference ON conditional_expression  }     |
|    |La dernière syntaxe LEFT OUTER JOIN n'existe que pour assurer la compatibilité avec   |
|    |ODBC.                                                                                 |
|    |Les références sur les tables peuvent être des alias.                                 |
|    |                                                                                      |
|    |mysql> select t1.name, t2.salary from employee AS t1, info AS t2                      |
|    |where t1.name = t2.name;                                                              |
|    |INNER JOIN et , (comma) sont équivalents. Les deux effectuent un regroupement des     |
|    |tables utilisées. Normalement, il faut préciser comment les tables sont reliées avec  |
|    |la condition WHERE .                                                                  |
|    |La condition ON est identique à WHERE.                                                |
|    |Si il n'y a pas de lignes qui correspondent à la table de gauche, dans la clause LEFT |
|    |JOIN, une ligne dont toutes les colonnes sont mises à NULL est générée. Ceci permet de|
|    |rechercher les lignes d'une table qui n'ont pas de contrepartie dans une autre table. |
|    |                                                                                      |
|    |mysql> select table1.* from table1                                                    |
|    |LEFT JOIN table2 ON table1.id=table2.id                                               |
|    |where table2.id is NULL;                                                              |
|    |Cet exemple recherche toutes les lignes dans la table1 avec une colonne id qui n'est  |
|    |pas présent dans la table table2 (i.e., toutes les lignes de la table table1 qui n'ont|
|    |pas de ligne correspondantes dans la table table2). Cela implique que a été déclaré   |
|    |table1.id, bien entendu !                                                             |
|    |La clause USING column_list spécifie une liste de nom de colonne qui doivent exister  |
|    |dans toutes les tables. Une utilisation telle que                                     |
|    |                                                                                      |
|    |A LEFT JOIN B USING (C1,C2,C3,...)                                                    |
|    |Correspond à l'utilisation d'une clause ON comme ceci :                               |
|    |                                                                                      |
|    |A.C1=B.C1 AND A.C2=B.C2 AND A.C3=B.C3,...                                             |
|    |La clause NATURAL LEFT JOIN de deux tables est équivalent à utilisation de la clause  |
|    |LEFT JOIN avec USING, en précisant les noms de toutes les colonnes qui existent dans  |
|    |les deux tables.                                                                      |
|    |STRAIGHT_JOIN est identique à JOIN, à l'exception du fait que la table de gauche est  |
|    |lue avant la table de droite. Cela est pratique pour les (rares) cas o√π l'optimiseur  |
|    |de regroupement utilise les tables dans le mauvais ordre .                            |
|    |Quelques exemples                                                                     |
|    |                                                                                      |
|    |mysql> select * from table1,table2 where table1.id=table2.id;                         |
|    |mysql> select * from table1 LEFT JOIN table2 ON table1.id=table2.id;                  |
|    |mysql> select * from table1 LEFT JOIN table2 USING (id);                              |
|    |mysql> select * from table1 LEFT JOIN table2 ON table1.id=table2.id                   |
|    |LEFT JOIN table3 ON table2.id=table3.id;                                              |
|    |LEFT JOIN optimization.                                                               |
|    |7.13 INSERT                                                                           |
|    |                                                                                      |
|    |INSERT [LOW_PRIORITY | DELAYED] [IGNORE]                                              |
|    |[INTO] Nom_table [(Nom_col,...)]                                                      |
|    |VALUES (expression,...),(...),...                                                     |
|    |ou  INSERT [LOW_PRIORITY | DELAYED] [IGNORE]                                          |
|    |[INTO] Nom_table [(Nom_col,...)]                                                      |
|    |SELECT ...                                                                            |
|    |ou  INSERT [LOW_PRIORITY | DELAYED] [IGNORE]                                          |
|    |[INTO] Nom_table                                                                      |
|    |SET Nom_col=expression, Nom_col=expression, ...                                       |
|    |INSERT insère une nouvelle ligne dans une table existante.. La forme de INSERT ...    |
|    |VALUES est basée sur des colonnes explicitement précisée. forme de INSERT ... SELECT  |
|    |insère des données depuis une autre table. La forme de INSERT ... VALUES avec         |
|    |plusieurs valeurs est acceptée MySQL à partir de la version 3.22.5 . La syntaxe       |
|    |Nom_col=expression est accepté par MySQL à partir de la version 3.22.10.              |
|    |Nom_table est le nom de la table dans laquelle les lignes vont être insérée. La liste |
|    |de nom de colonne ou la clause SET indique quelles colonnes vont être assignées.      |
|    |Si aucun nom de colonne n'est précisé dans la commande, INSERT ... VALUES or INSERT   |
|    |... SELECT, alors des valeurs doivent être fournies pour toutes les colonnes dans la  |
|    |liste de VALUES(). Pour connaître l'ordre des colonnes, il faut utiliser la commande  |
|    |DESCRIBE Nom_table.                                                                   |
|    |Toute colonne qui n'a pas de valeur explicitement fournie est mise à sa valeur par    |
|    |défaut. Par exemple, il est possible de fournir une liste de colonne en omettant      |
|    |certains noms : les valeurs de ces colonnes seront les valeurs par défaut. Pour avoir |
|    |les détails sur les valeurs par défaut, CREATE TABLE.                                 |
|    |Une expression peut faire référence à n'importe quelle colonne déjà nommée dans la    |
|    |liste des colonnes. Par exemple :                                                     |
|    |                                                                                      |
|    |mysql> INSERT INTO Nom_table (col1,col2) VALUES(15,col1*2);                           |
|    |Mais pas ceci :                                                                       |
|    |                                                                                      |
|    |mysql> INSERT INTO Nom_table (col1,col2) VALUES(col2*2,15);                           |
|    |L'option LOW_PRIORITY permet de différer une exécution jusqu'à ce qu'il n'y ait plus  |
|    |de client qui lisent la table.                                                        |
|    |L'option permet, lors de l'insertion dans une table qui a une colonne de type PRIMARY |
|    |or UNIQUE , de ne pas renvoyer d'erreur si une insertion essaie de doubler une clé    |
|    |déjà existante. Si cette option n'est pas précisée, l'insertion est annulée à partir  |
|    |de la ligne erronée. Le nombre de ligne correctement insérées est accessible avec     |
|    |mysql_info() .                                                                        |
|    |Si MySQL a été configuré avec l'option DONT_USE_DEFAULT_FIELDS , une commande INSERT  |
|    |devra avoir la liste complète des colonnes qui requière une valeur non-NULL.          |
|    |Les conditions suivantes s'appliquent aux commandes de type INSERT INTO ... SELECT    |
|    |La requête ne peut pas contenir de clause ORDER BY                                    |
|    |La table cible de l'insertion ne peut pas apparaître dans la clause FROM du SELECT,   |
|    |car la norme ANSI SQL l'interdit (en effet, le SELECT pourrait trouver des lignes qui |
|    |viennent juste d'être insérée. Utiliser des sous-selections serait encore pire).      |
|    |Les colonnes de type AUTO_INCREMENT fonctionnent de la même façon.                    |
|    |Lors de l'utilisation de INSERT ... SELECT ou INSERT ... VALUES avec des listes de    |
|    |plusieurs lignes, la fonction mysql_info() permet d'obtenir des informations sur la   |
|    |requête. Le format de la réponse est comme suite :                                    |
|    |                                                                                      |
|    |Records: 100 Duplicates: 0 Warnings: 0                                                |
|    |Duplicates indique le nombre de lignes qui n'a pas pus être insérées car elles        |
|    |tentaient de doubler une clé primaire.. Warnings indique le nombre d'insertions qui   |
|    |ont générer une erreur lors de l'insertion. Warnings surviennent lorsqu'il y a une    |
|    |tentative:                                                                            |
|    |Insertion d'une valeur NULL dans une colonne déclarée NOT NULL.                       |
|    |Assignation d'une valeur numérique qui est hors de l'intervalle de validité de la     |
|    |colonne. Cette valeur est ramenée à la valeur valide la plus proche.                  |
|    |Assignation d'une valeur telle que '10.34 a'. Dans ce cas, les résidus inutiles sont  |
|    |éliminés. Si la valeur ne peut pas être interprétée, la valeur 0 est assignée à la    |
|    |place.                                                                                |
|    |Insertion d'une chaîne dans une colonne de type CHAR, VARCHAR, TEXT ou BLOB qui excède|
|    |la longueur maximale. La valeur est alors tronquée à la taille maximale de la colonne.|
|    |                                                                                      |
|    |Insertion d'une valeur invalide dans une date ou heure. La valeur est alors fixée au  |
|    |``zéro'' du type de la colonne.                                                       |
|    |L'option DELAYED pour la commande INSERT est une caractéristique MySQL qui est très   |
|    |utile lorsque les clients ne peuvent pas attendre la fin de l'insertion. C'est utilisé|
|    |habituellement par MySQL pour remplir des historiques, et que périodiquement, une     |
|    |longue commande SELECT est effectuée. DELAYED a été introduit à partir de MySQL       |
|    |3.22.15. C'est une extension MySQL à la norme ANSI SQL92.                             |
|    |Un autre avantage majeur de l'utilisation de la commande INSERT DELAYED est que les   |
|    |insertions sont regroupées et traitées en même temps. C'est une manière plus rapide   |
|    |que d'effectuer autant d'insertions unitaires.                                        |
|    |Il faut noter que les insertions en attente sont gardées en mémoire vive, jusqu'à ce  |
|    |qu'elles soient insérées dans la table. Cela signifie que si le processus mysqld est  |
|    |brutalement interrompu (kill -9) ou si mysqld se termine inopinément, les lignes ne   |
|    |seront pas écrites sur le disque, et ainsi perdues !                                  |
|    |Les événements suivants surviennent lors de l'utilisation de l'option DELAYED des     |
|    |commandes INSERT ou REPLACE. Dans la description qui suit, le ``thread'' est le thread|
|    |qui a recu la commande INSERT DELAYED et ``handler'' est le thread qui va gérer les   |
|    |INSERT DELAYED pour une table particulière.                                           |
|    |Quand un thread exécute la commande DELAYED pour une table, le thread handler est crée|
|    |pour gérer toutes les commandes DELAYED pour la table, si un tel thread n'existe pas. |
|    |Le thread vérifie si le handler a bien posé un verrou DELAYED, et si non, il lui dit  |
|    |de le faire. Le verrou DELAYED peut être obtenu même si d'autres threads ont déjà     |
|    |obtenu un verrou de READ ou WRITE sur la table. Cependant, le handler va attendre que |
|    |tous les verrous ALTER TABLE ou FLUSH TABLES soient libérés, afin de s'assurer que la |
|    |table est bien à jour.                                                                |
|    |Le thread exécute l'insertion mais, au lieu d'écrire la ligne dans la table, il       |
|    |transmet une copie de la ligne finale au handler, qui l'ajoute dans la queue          |
|    |d'attente. Toutes les erreurs d'insertions sont notées par le thread, et rapportées au|
|    |client.                                                                               |
|    |Le client ne reçoit pas le nombre de doublons, ou la valeur d' AUTO_INCREMENT qu'il   |
|    |pourrait attendre, car ces informations ne sont connues qu'après l'insertion          |
|    |proprement dite. De la même façon, mysql_info()risque de retourner des informations   |
|    |incohérentes.                                                                         |
|    |L'historique de mise à jour est modifié par le handler quand la ligne est             |
|    |effectivement insérée dans la table. Si il y a plusieurs lignes insérées              |
|    |simultanément, l'historique de mise à jour est modifié lors de l'insertion de la      |
|    |première ligne.                                                                       |
|    |Après chaque bloc de delayed_insert_limit lignes écrites, le handler vérifie si il n'y|
|    |a pas de commande SELECT en attente. Si c'est le cas, il s'arrête, et l'exécute avant |
|    |de continuer.                                                                         |
|    |Quand le handler n'a plus de ligne dans la queue, la table est déverrouillée. Si      |
|    |aucune autre commandes INSERT DELAYED n'est reçue dans un délai de                    |
|    |delayed_insert_timeout secondes, le handler se termine.                               |
|    |Si il reste plus de delayed_queue_size lignes en attente d'insertion, le thread attend|
|    |jusqu'à ce qu'il y ait de la place dans la queue. Ce permet de contrôler la quantité  |
|    |de mémoire utilisé pour les queues d'attentes.                                        |
|    |Le handler apparaîtra dans la liste des processus MySQL avec le mot delayed_insert    |
|    |dans la colonne de Command . Il sera automatiquement effacé lors d'une commande FLUSH |
|    |TABLES ou KILL thread_id. Cependant, il enregistrera les lignes dans la table avant de|
|    |quitter. Durant cette période, le handler n'acceptera plus aucune nouvelle commande   |
|    |INSERT d'un autre thread. Si une nouvelle commande an INSERT DELAYED est éxécutée, un |
|    |nouveau handler sera créé.                                                            |
|    |Il faut bien noter que les commandes INSERT DELAYED ont une priorité supérieure aux   |
|    |commandes INSERT, si un handler est déjà en fonctionnement. Toutes les autres         |
|    |commandes doivent attendre que la queue d'attente du handler soit vide (même par un   |
|    |kill).                                                                                |
|    |Les statuts suivants fournissent des informations sur l'état des commandes INSERT     |
|    |DELAYED :                                                                             |
|    |Ces variables sont accessibles avec la commande SHOW STATUS ou, en ligne, avec        |
|    |mysqladmin extended-status.                                                           |
|    |7.14 REPLACE                                                                          |
|    |                                                                                      |
|    |REPLACE [LOW_PRIORITY | DELAYED]                                                      |
|    |[INTO] Nom_table [(Nom_col,...)]                                                      |
|    |VALUES (expression,...)                                                               |
|    |ou  REPLACE [LOW_PRIORITY | DELAYED]                                                  |
|    |[INTO] Nom_table [(Nom_col,...)]                                                      |
|    |SELECT ...                                                                            |
|    |ou  REPLACE [LOW_PRIORITY | DELAYED]                                                  |
|    |[INTO] Nom_table                                                                      |
|    |SET Nom_col=expression, Nom_col=expression,...                                        |
|    |REPLACE fonctionne exactement comme INSERT, mais si une ligne d'une table a une       |
|    |colonne qui porte l'attribut unique , REPLACE pourra remplacer cette ligne par une    |
|    |nouvelle ligne, tout en gardant la même valeur dans la colonne de type unique. Pour   |
|    |plus de détails, voir INSERT.                                                         |
|    |7.15 LOAD DATA INFILE                                                                 |
|    |                                                                                      |
|    |LOAD DATA [LOCAL] INFILE 'file_name.txt' [REPLACE | IGNORE]                           |
|    |INTO TABLE nom_table                                                                  |
|    |[FIELDS                                                                               |
|    |[TERMINATED BY '\t']                                                                  |
|    |[OPTIONALLY] ENCLOSED BY '']                                                          |
|    |[ESCAPED BY '\\' ]]                                                                   |
|    |[LINES TERMINATED BY '\n']                                                            |
|    |[IGNORE number LINES]                                                                 |
|    |[(nom_colonne,...)]                                                                   |
|    |La commande LOAD DATA INFILE lit des lignes à partir d'un fichier, et le transforme en|
|    |table, à très grande vitesse. Si l'option LOCAL est précisée, le fichier est lu depuis|
|    |le client (cette fonction est disponible à partir la version 3.22.6 de MySQL.)        |
|    |Pour des raisons de sécurité, lors de la lecture de fichier situé sur le serveur, les |
|    |fichiers doivent être disponibles dans le dossier de MySQL, ou bien lisible par tous. |
|    |De plus, pour utiliser LOAD DATA INFILE sur des fichiers serveurs, il faut avoir les  |
|    |droits fichiers.                                                                      |
|    |Utiliser l'option LOCAL est un peu plus lente que l'option par défaut, car le contenu |
|    |des fichiers doit du client vers le serveur. D'un autre coté, il n'y plus de problème |
|    |de droits d'accès.                                                                    |
|    |L'utilitaire mysqlimport assure aussi l'importation de fichier. Il le fait en envoyant|
|    |une requête LOAD DATA INFILE au serveur. L'option –local force mysqlimport à lire le  |
|    |fichier depuis l'hôte client. Si le client et le serveur supporte le protocole        |
|    |compressé, l'option --compress donnera de meilleures performances sur des réseaux     |
|    |chargés.                                                                              |
|    |Pour retrouver les fichiers sur le serveur, le serveur utilise les règles suivantes : |
|    |Si un chemin absolu est fourni, le serveur utilise le chemin tel quel.                |
|    |Si un chemin relatif est fourni, avec un ou plusieurs composant, le serveur recherche |
|    |le fichier dans le dossier données de la base de données.                             |
|    |Si un nom de fichier est fourni, le serveur va le rechercher dans le dossier de la    |
|    |base de données courante.                                                             |
|    |Il faut noter que ces règles signifie que le fichier ``./monFichier.txt'' sera lu     |
|    |depuis le dossier données du serveur, tandis que ``myfile.txt'' sera lu depuis le     |
|    |dossier de la base de données courante. Il faut aussi noter qu'avec la commande       |
|    |ci-dessous, le fichier est lu depuis le dossier de la base db1, et non pas db2 :      |
|    |                                                                                      |
|    |mysql> USE db1;                                                                       |
|    |mysql> LOAD DATA INFILE "./data.txt" INTO TABLE db2.my_table;                         |
|    |Les options REPLACE et IGNORE règlent la gestion index redondants, dans les colonnes  |
|    |de type unique. Avec REPLACE, la nouvelle ligne remplacera l'ancienne, avec la même   |
|    |valeur d'index. Avec IGNORE, la nouvelle ligne sera ignorée. Si rien n'est précisé,   |
|    |une erreur surviendra lors de la tentative d'insertion du doublon, et le reste du     |
|    |fichier sera ignoré.                                                                  |
|    |Lors du chargement de lignes à partir d'un fichier local et avec l'option LOCAL, le   |
|    |serveur n'a aucun moyen d'interrompre la transmission du fichier durant l'opération,  |
|    |alors le comportement par défaut est IGNORE.                                          |
|    |DATA INFILE est la commande complémentaire de SELECT ... INTO OUTFILE. SELECT. Pour   |
|    |écrire des lignes depuis une base de données vers un fichier, il faut utiliser SELECT |
|    |... INTO OUTFILE. Pour lire des lignes depuis un fichier vers une base, il faut       |
|    |utiliser LOAD DATA INFILE. La syntaxe des clauses FIELDS et LINES est la même pour les|
|    |deux commandes. Ces deux clauses sont optionnelles, mais FIELDS doit impérativement   |
|    |précéder LINES si les deux sont présents.                                             |
|    |Si la clause est FIELDS présente, alors chacune des sous clauses (TERMINATED BY,      |
|    |[OPTIONALLY] ENCLOSED BY t ESCAPED BY) sont optionnelles, mais il faut au moins en    |
|    |spécifier une.                                                                        |
|    |Si la clause FIELDS n'est pas spécifiée, les valeurs par défaut sont les suivantes :  |
|    |                                                                                      |
|    |FIELDS TERMINATED BY '\t' ENCLOSED BY '' ESCAPED BY '\\'                              |
|    |Si la clause LINES n'est pas spécifiée, les valeurs par défaut sont les suivantes :   |
|    |                                                                                      |
|    |LINES TERMINATED BY '\n'                                                              |
|    |En bref, les options par défaut de LOAD DATA INFILE fonctionnent comme suit :         |
|    |Recherche de la limite de ligne                                                       |
|    |Segmenter la ligne en champs, gr?ce aux tabulations                                   |
|    |Ne pas s'attendre à ce que les champs soient entourés de guillemets                   |
|    |Interpréter les occurrences de tabulation, nouvelle ligne, ou backslash ``\'' précédés|
|    |par ``\'' comme des caractères à part entières                                        |
|    |Dans le sens inverse, les options par défaut de SELECT ... INTO OUTFILE fonctionnent  |
|    |comme suit :                                                                          |
|    |Ecrire des tabulations entre les champs                                               |
|    |Ne pas entourer les champs avec des guillemets                                        |
|    |Ajouter un backslash ``\'' avant toutes les occurrences de tabulation, nouvelle ligne,|
|    |ou backslash ``\'.'                                                                   |
|    |Ecrire une nouvelle ligne à chaque fin de ligne.                                      |
|    |Il faut noter que pour écrire write FIELDS ESCAPED BY '\\', il faut écrire 2 backslash|
|    |pour en avoir un de lu.                                                               |
|    |L'option IGNORE number LINES permet d'ignorer les premières lignes, qui contiendrait  |
|    |un entête, par exemple.                                                               |
|    |                                                                                      |
|    |mysql> LOAD DATA INFILE "/tmp/Nom_fichier" into table test IGNORE 1 LINES;            |
|    |Pour pouvoir écrire un fichier avec SELECT ... INTO OUTFILE, puis le relire LOAD DATA |
|    |INFILE ultérieurement avec, il est impératif que les options de lecture et d'écriture |
|    |soient les mêmes. Sinon, l'interprétation du fichier à la relecture sera erronée. Par |
|    |exemple, un fichier est écrit avec SELECT ... INTO OUTFILE avec des virgules comme    |
|    |délimiteur de champs :                                                                |
|    |                                                                                      |
|    |mysql> SELECT * FROM table1 INTO OUTFILE 'data.txt'                                   |
|    |FIELDS TERMINATED BY ','                                                              |
|    |FROM ...                                                                              |
|    |Pour relire ce fichier, la bonne commande est :                                       |
|    |                                                                                      |
|    |mysql> LOAD DATA INFILE 'data.txt' INTO TABLE table2                                  |
|    |FIELDS TERMINATED BY ',';                                                             |
|    |Si, au contraire, le fichier est relu avec la commande ci-dessous, la relecture sera  |
|    |erronée, car les délimiteurs attendus sont des tabulations :                          |
|    |                                                                                      |
|    |mysql> LOAD DATA INFILE 'data.txt' INTO TABLE table2                                  |
|    |FIELDS TERMINATED BY '\t';                                                            |
|    |Il est probable que le fichier soit interprété comme un seul champs.                  |
|    |LOAD DATA INFILE peut aussi lire des fichiers issues d'autres sources. Par exemple, un|
|    |fichier au format dBase a des champs séparés par des virgules, et insérés dans des    |
|    |doubles guillemets. Si les lignes dans le fichier sont terminées par des nouvelles    |
|    |lignes, la commande suivante permettra d'acquérir un fichier au format.               |
|    |                                                                                      |
|    |mysql> LOAD DATA INFILE 'data.txt' INTO TABLE Nom_table                               |
|    |FIELDS TERMINATED BY ',' ENCLOSED BY '"'                                              |
|    |LINES TERMINATED BY '\n';                                                             |
|    |Les options FIELDS ou LINES peuvent être des chaînes vides. Si ils ne sont pas vides, |
|    |les options FIELDS [OPTIONALLY] ENCLOSED BY et FIELDS ESCAPED BY doivent être une     |
|    |chaîne d'un seul caractère. Les options FIELDS TERMINATED BY et LINES TERMINATED BY   |
|    |peuvent avoir un ou plusieurs caractères. Par exemple, si les lignes sont terminées   |
|    |par la paire retour-chariot/nouvelle-ligne, il est possible d'utiliser l'option LINES |
|    |TERMINATED BY '\r\n'.                                                                 |
|    |Contrôle les caractères qui entoure les champs. Lors de l'exportation(SELECT ... INTO |
|    |OUTFILE), l'absence de l'option OPTIONALLY force tous les champs à être entouré par le|
|    |caractère ENCLOSED BY. Par exemple, en utilisant la virgule comme délimiteur de champs|
|    |:                                                                                     |
|    |                                                                                      |
|    |"1","une chaîne","100.20"                                                             |
|    |"2"," une chaîne contenant une , virgule","102.20"                                    |
|    |"3"," une chaîne contenant un \" guillemet","102.20"                                  |
|    |"4"," une chaîne contenant un \", guillemet et une virgule","102.20"                  |
|    |L'option OPTIONALLY force l'utilisation du caractère ENCLOSED BY seulement pour les   |
|    |champs de type CHAR et VARCHAR.                                                       |
|    |                                                                                      |
|    |1," une chaîne ",100.20                                                               |
|    |2," une chaîne contenant une , virgule ",102.20                                       |
|    |3," une chaîne contenant un \" guillemet ",102.20                                     |
|    |4," une chaîne contenant un \", guillemet et une virgule ",102.20                     |
|    |On peut noter que les occurrences du caractère ENCLOSED BY situés dans une chaîne sont|
|    |toujours échappée, gr?ce au caractère ENCLOSED BY. On peut aussi noter que si le      |
|    |caractère d'échappement est une chaîne vide, le fichier ne pourra pas être relu       |
|    |correctement par LOAD DATA INFILE. Par exemple, le fichier de sortie ci-dessus, va    |
|    |devenir le fichier de sortie ci-dessous, si le caractère d'échappement est vide. Lors |
|    |de la relecture, un problème surviendra surement durant la deuxième ligne :           |
|    |                                                                                      |
|    |1," une chaîne ",100.20                                                               |
|    |2," une chaîne contenant une , virgule ",102.20                                       |
|    |3," une chaîne contenant un " guillemet ",102.20                                      |
|    |4," une chaîne contenant un \", guillemet et une virgule ",102.20                     |
|    |En entrée, le caractère est éliminé à la fin de chaque champs. (ceci est vrai, qu'il y|
|    |ai l'option OPTIONALLY ou pas. OPTIONALLY n'a pas d'impact sur la procédure           |
|    |d'acquisition). Les occurrences du caractère ENCLOSED BY précédés du caractère        |
|    |d'échappement ESCAPED BY sont considérés comme une partie du champs. De plus, les     |
|    |caractères ENCLOSED BY doublés sont considérés comme une seule occurrence. Par        |
|    |exemple, le caractère ENCLOSED BY est '"' alors, les lignes suivantes deviennent :    |
|    |                                                                                      |
|    |"Le ""GRAND"" chef"  -> Le "GRAND" chef                                               |
|    |Le "GRAND" chef -> Le "GRAND" chef                                                    |
|    |Le ""GRAND"" chef -> Le ""GRAND"" chef                                                |
|    |FIELDS ESCAPED BY contrôle l'écriture et la lecture des caractères spéciaux . Si      |
|    |l'option FIELDS ESCAPED BY n'est pas une chaîne vide, il sert de préfixe dans les cas |
|    |suivants                                                                              |
|    |Pour le caractère FIELDS ESCAPED BY                                                   |
|    |Pour le caractère FIELDS [OPTIONALLY] ENCLOSED BY                                     |
|    |Pour le premier caractère FIELDS TERMINATED BY et LINES TERMINATED BY                 |
|    |Pour le caractère ASCII 0 (qui sera en fait écrit avec la séquence caractère          |
|    |d'échappement suivi de 0 )                                                            |
|    |Si le caractère FIELDS ESCAPED BY est une chaîne vide, aucun caractère ne sera        |
|    |échappé. Ce n'est pas une très bonne idée, surtout si certains champs contiennent l'un|
|    |des caractères de la liste ci-dessus.                                                 |
|    |En lecture, si le caractère FIELDS ESCAPED BY n'est pas une chaîne vide, les          |
|    |occurrences de ce caractère seront éliminées, et le caractère suivant sera lu         |
|    |littéralement, comme une partie du champs. Exceptions faites de ``0'' et ``N'' (i.eI.,|
|    |\0 ou \N avec ``\' 'comme caractère d'échappement). Ces séquences seront interprétées |
|    |comme ASCII 0 (le caractère nul) et NULL. Voir ci dessous pour les règles de          |
|    |sauvegarde NULL .                                                                     |
|    |Pour plus d'informations à propos des séquences d'échappement, Literals.              |
|    |Dans certains cas, les options FIELDS et LINES de interagissent :                     |
|    |Si LINES TERMINATED BY est une chaîne vide, et FIELDS TERMINATED BY est une chaîne non|
|    |vide, les lignes seront aussi terminées FIELDS TERMINATED BY.                         |
|    |Si FIELDS TERMINATED BY et FIELDS ENCLOSED BY sont tous les deux des chaînes vides    |
|    |(''), un format à longueur fixe est utilisé. Avec le format à longueur fixe, il n'y a |
|    |plus besoin de délimiteurs. A la place, les colonnes et les lignes sont écrites en    |
|    |utilisant la taille d'affichage des colonnes. Par exemple, si une colonne est déclarée|
|    |de type INT(7), les valeurs seront écrite en utilisant des colonne de 7 caractères. En|
|    |lecture, les données sont obtenues en lisant 7 caractères. Les fichiers sans          |
|    |délimiteurs ont un impact sur la façon avec laquelle la valeur NULL est enregistrée.  |
|    |La gestion de la valeur NULL dépends des options FIELDS et LINES utilisées :          |
|    |Par pour les valeurs par défaut de FIELDS and LINES, NULL est symbolisé par as \N en  |
|    |lecture et en écriture. (en supposant que le caractère ESCAPED BY est ``\'').         |
|    |Si FIELDS ENCLOSED BY n'est pas vide, un champs contenant littéralement la chaîne NULL|
|    |est utilisé, en écriture et en lecture. (Ceci est différent du mot 'NULL', entouré de |
|    |caractères FIELDS ENCLOSED BY et lu comme la chaîne 'NULL').                          |
|    |Si FIELDS ESCAPED BY est vide, NULL est directement écrit NULL.                       |
|    |Avec le format à largueur de colonne fixée, (ce qui arrive lorsque FIELDS TERMINATED  |
|    |BY et FIELDS ENCLOSED BY sont tous les deux vides), NULL s'écrit comme une chaîne     |
|    |vide. Il faut noter que cela entraîne l'identité de la valeur NULL et des chaînes     |
|    |vides. Il ne sera alors pas possible d'en faire la différence.                        |
|    |Certains cas ne sont pas accepté par LOAD DATA INFILE:                                |
|    |Lignes de taille fixe (FIELDS TERMINATED BY et FIELDS ENCLOSED BY tous les deux vides)|
|    |et des colonnes de type BLOB ou TEXT.                                                 |
|    |Si deux séparateurs sont identiques, LOAD DATA INFILE ne seront pas capable           |
|    |d'interpréter le fichier. Par exemple, le champs FIELDS va poser problème:            |
|    |                                                                                      |
|    |FIELDS TERMINATED BY '"' ENCLOSED BY '"'                                              |
|    |Si FIELDS ESCAPED BY est vide, un champs qui contient une occurrence de FIELDS        |
|    |ENCLOSED BY ou LINES TERMINATED BY suivi FIELDS TERMINATED BY va provoquer une erreur,|
|    |et l'arret de la lecture du fichier. Ceci, car LOAD DATA INFILE ne peut pas determiner|
|    |correctement la fin de la valeur, ou du champs.                                       |
|    |Les exemples suivants charge toutes les colonnes de la tables persondata:             |
|    |                                                                                      |
|    |mysql> LOAD DATA INFILE 'persondata.txt' INTO TABLE persondata;                       |
|    |Aucun champs n'est précisé, alors LOAD DATA INFILE s'attend à trouver une valeur pour |
|    |chaque colonne. Les valeurs par défaut FIELDS et LINES sont supposés.                 |
|    |Pour ne charger qu'une partie des colonnes, on peut utiliser :                        |
|    |                                                                                      |
|    |mysql> LOAD DATA INFILE 'persondata.txt'                                              |
|    |INTO TABLE persondata (col1,col2,...);                                                |
|    |Il faut aussi préciser la liste des champs dans l'ordre d'apparition de celles ci dans|
|    |le fichier, surtout si elles apparaissent dans un autre ordre que celui de la table.  |
|    |Si il manque des champs, les colonnes qui n'ont pas de valeurs seront mises à leur    |
|    |valeur par défaut. Les valeurs par défaut sont décrites dans la section CREATE TABLE. |
|    |La valeur d'un champs vide est interprété différemment, suivant le champs manquant :  |
|    |Pour les champs de type chaîne, la colonne prend la valeur de la chaîne vide.         |
|    |Pour les types numériques, la colonne prend la valeur 0.                              |
|    |Pour les types date et heures, la colonne prend la valeur ``zéro'' adéquate. 7.2.6    |
|    |Types date et heure.                                                                  |
|    |Les colonnes de type TIMESTAMP prennent la valeur de l'heure et la date courante si   |
|    |une NULL leur est affectée. ou (pour la première colonne de type TIMESTAMP) si la     |
|    |colonne est omise de la liste de champs à lire.                                       |
|    |Si une ligne à trop de champs, les champs supplémentaires sont ignorés, et le nombre  |
|    |d'alerte est augmenté.                                                                |
|    |LOAD DATA INFILE considère toutes les valeurs en entrées comme des chaînes, donc il   |
|    |n'est pas possible d'utiliser les formes numériques, notamment pour les types ENUM ou |
|    |SET . . Toutes les énumérations doivent être spécifiée comme des chaînes              |
|    |Lors de l'utilisation de LOAD DATA INFILE, la fonction mysql_info() permet d'obtenir  |
|    |des informations sur la requête. Le format de la réponse est comme suite :            |
|    |                                                                                      |
|    |Records: 100 Duplicates: 0 Warnings: 0                                                |
|    |Duplicates indique le nombre de lignes qui n'a pas pus être insérées car elles        |
|    |tentaient de doubler une clé primaire.. Warnings indique le nombre d'insertions qui   |
|    |ont générer une erreur lors de l'insertion. Warnings surviennent lorsqu'il y a une    |
|    |tentative incorrecte d'insertion de ligne.                                            |
|    |7.16 UPDATE                                                                           |
|    |                                                                                      |
|    |UPDATE [LOW_PRIORITY] nom_table SET nom_colonne1=expr1,nom_colonne2=expr2,...         |
|    |[WHERE where_definition] [LIMIT #]                                                    |
|    |UPDATE met à jour une ligne éxistante dans une table. La clause SET indique quelles   |
|    |colonnes modifier, et quelles valeurs mettre dans ces colonnes. La conditions WHERE   |
|    |permet de choisir quelles lignes sont à mettre à jour. Sinon, toutes les lignes sont  |
|    |mises à jour                                                                          |
|    |L'option LOW_PRIORITY, permet de retarder l'exécution de la requête jusqu'au moment où|
|    |il n'y a plus de client qui lisent la table                                           |
|    |Lors de l'accès à une colonne de la table Nom_table dans une expression, UPDATE       |
|    |utilise la valeur courante de la colonne. Par exemple, la requête suivante ajoute 1 à |
|    |la colonne age.                                                                       |
|    |                                                                                      |
|    |mysql> UPDATE persondata SET age=age+1;                                               |
|    |Les commandes UPDATE sont évaluées de gauche à droite. Par exemple, la requête        |
|    |suivante double la colonne age, puis l'incrémente d'une unité :                       |
|    |                                                                                      |
|    |mysql> UPDATE persondata SET age=age*2, age=age+1;                                    |
|    |Affecter la valeur courante d'une colonne lors d'une commande UPDATE conduit MySQL à  |
|    |ignore cette mise à jour.                                                             |
|    |La commande UPDATE retourne le nombre de ligne qui ont été effectivement modifiées.. A|
|    |partir de MySQL 3.22, la fonction C API mysql_info()nombre de ligne qui ont été       |
|    |trouvées et effectivement modifiées, puis le nombre de warnings de la commande UPDATE.|
|    |                                                                                      |
|    |7.17 USE                                                                              |
|    |                                                                                      |
|    |USE Nom_bdd                                                                           |
|    |La commande USE Nom_bdd statement indique à MySQL le nom de la base de données par    |
|    |défaut pour les requête suivantes. Cette base restera courante jusqu'à la fin de la   |
|    |session, ou jusqu'à la prochaine utilisation de la commande USE:                      |
|    |                                                                                      |
|    |mysql> USE db1;                                                                       |
|    |mysql> SELECT count(*) FROM maTable;      # selects from db1.maTable                  |
|    |mysql> USE db2;                                                                       |
|    |mysql> SELECT count(*) FROM maTable;      # selects from db2.maTable                  |
|    |L'utilisation d'une base de données par défaut n'empêche pas l'accès aux autres bases.|
|    |Par exemple, il est toujours possible d'accéder à la table editeur de la base db2,    |
|    |même après l'utilisation de USE db1                                                   |
|    |                                                                                      |
|    |mysql> USE db1;                                                                       |
|    |mysql> SELECT author_name,editor_name FROM author,db2.editor                          |
|    |WHERE author.editor_id = db2.editor.editor_id;                                        |
|    |La commande USE est fournie pour assurer la compatibilité avec Sybase.                |
|    |7.18 FLUSH (vider les caches)                                                         |
|    |                                                                                      |
|    |FLUSH flush_option [,flush_option]                                                    |
|    |La commande FLUSH permet d'effacer les caches internes de MySQL uses. Pour l'exécuter,|
|    |il faut avoir les droits de rechargement (reload ).                                   |
|    |flush_option peut prendre les valeurs suivantes :                                     |
|    |Ces commandes sont disponibles avec l'utilitaire mysqladmin, en utilisant les options |
|    |flush-hosts, flush-logs, reload ou flush-tables.                                      |
|    |7.19 KILL                                                                             |
|    |                                                                                      |
|    |KILL thread_id                                                                        |
|    |                                                                                      |
|    |KILL thread_id                                                                        |
|    |Chaque connection à mysqld génére un thread séparé. La liste des threads est          |
|    |accessible avec la SHOW PROCESSLIST et la fonction KILL thread_id, permet de terminer |
|    |immédiatement ces threads.                                                            |
|    |Il faut avoir les droits de process pour voir et terminer tous les threads. Sinon,    |
|    |seul les threads utilisateurs sont visibles et terminables.                           |
|    |Ces commandes sont disponibles avec l'utilitaire mysqladmin en utilisant les options  |
|    |mysqladmin processlist and mysqladmin kill.                                           |
|    |7.20 SHOW (Informations sur les tables, colonnes,...)                                 |
|    |                                                                                      |
|    |SHOW DATABASES [LIKE wild]                                                            |
|    |ou SHOW TABLES [FROM Nom_bdd] [LIKE wild]                                             |
|    |ou SHOW COLUMNS FROM Nom_table [FROM Nom_bdd] [LIKE wild]                             |
|    |ou SHOW INDEX FROM Nom_table [FROM Nom_bdd]                                           |
|    |ou SHOW STATUS                                                                        |
|    |ou SHOW VARIABLES [LIKE wild]                                                         |
|    |ou SHOW PROCESSLIST                                                                   |
|    |ou SHOW TABLE STATUS [FROM Nom_bdd] [LIKE wild]                                       |
|    |SHOW fourni les caractéristiques des bases de données, tables et colonnes sur le      |
|    |serveur. Si l'option LIKE wild est utilisée, la chaîne wild peut utiliser les         |
|    |caractères spéciaux ``%'' et ``_''.                                                   |
|    |Il y a deux possibilités pour référencer une table : Nom_bdd.Nom_table ou Nom_table   |
|    |FROM Nom_bdd syntax. Les deux requêtes suivantes sont équivalentes :                  |
|    |                                                                                      |
|    |mysql> SHOW INDEX FROM maTable FROM maBase;                                           |
|    |mysql> SHOW INDEX FROM maBase.maTable;                                                |
|    |SHOW DATABASES fait la liste des bases de donnés sur le serveur MySQL. mysqlshow      |
|    |fournit les mêmes renseignements.                                                     |
|    |SHOW TABLES fait la liste des tables sur une base donnée. mysqlshow Nom_bdd fournit   |
|    |les mêmes renseignements.                                                             |
|    |Note: Si un utilisateur n'a aucun droit pour une table, la table n'apparaitra pas dans|
|    |les SHOW TABLES ou mysqlshow Nom_bdd.                                                 |
|    |SHOW COLUMNS fait la liste des colonnes d'une table. Si les types des colonnes sont   |
|    |différens de ce qui ont été spécifiés à la création, avec la CREATE TABLE, il faut    |
|    |savoir que parfois, MySQL change spontanément le type de colonnes. 7.6.1 Modifications|
|    |automatiques de type de colonne.                                                      |
|    |La commande DESCRIBE fournit les mêmes informations que SHOW COLUMNS. DESCRIBE.       |
|    |SHOW TABLE STATUS (nouveauté de la version 3.23) fonctionne comme SHOW STATUS, mais   |
|    |fournit beaucoup plus d'informations sur chaque table. L'utilitaire mysqlshow avec    |
|    |l'option --status Nom_bdd effectue la même requête. Les colonnes suivantes sont       |
|    |renvoyées :                                                                           |
|    |Name                                                                                  |
|    |Name of the table                                                                     |
|    |                                                                                      |
|    |Type                                                                                  |
|    |Type of table (NISAM, MyISAM or HEAP)                                                 |
|    |                                                                                      |
|    |Rows                                                                                  |
|    |Number of rows                                                                        |
|    |                                                                                      |
|    |Avg_row_length                                                                        |
|    |Average row length                                                                    |
|    |                                                                                      |
|    |Data_length                                                                           |
|    |Length of the data file                                                               |
|    |                                                                                      |
|    |Max_data_length                                                                       |
|    |Max length of the data file                                                           |
|    |                                                                                      |
|    |Index_length                                                                          |
|    |Length of the index file                                                              |
|    |                                                                                      |
|    |Data_free                                                                             |
|    |Number of allocated but not used bytes                                                |
|    |                                                                                      |
|    |Auto_increment                                                                        |
|    |Next autoincrement value                                                              |
|    |                                                                                      |
|    |Create_time                                                                           |
|    |When the table was created                                                            |
|    |                                                                                      |
|    |Update_time                                                                           |
|    |When the data file was last updated                                                   |
|    |                                                                                      |
|    |Check_time                                                                            |
|    |When one last run a check on the table                                                |
|    |                                                                                      |
|    |Create_options                                                                        |
|    |Extra options used with CREATE TABLE                                                  |
|    |                                                                                      |
|    |Comment                                                                               |
|    |The comment used when creating the table (or some information why MySQL couldn't      |
|    |access the table information).                                                        |
|    |                                                                                      |
|    |SHOW FIELDS est un synonyme de SHOW COLUMNS et SHOW KEYS est un synonyme de SHOW INDEX|
|    |Ces commandes sont disponibles avec l'utilitaire mysqlshow Nom_bdd Nom_table ou       |
|    |mysqlshow -k Nom_bdd Nom_table.                                                       |
|    |SHOW INDEX retourne les informations dans un format proche de SQLStatistics sous ODBC.|
|    |Les informations suivantes sont disponibles :                                         |
|    |Table                                                                                 |
|    |Name of the table                                                                     |
|    |                                                                                      |
|    |Non_unique                                                                            |
|    |0 if the index can't contain duplicates.                                              |
|    |                                                                                      |
|    |Key_name                                                                              |
|    |Name of the index                                                                     |
|    |                                                                                      |
|    |Seq_in_index                                                                          |
|    |Column sequence number in index, starting with 1.                                     |
|    |                                                                                      |
|    |Column_name                                                                           |
|    |Column name.                                                                          |
|    |                                                                                      |
|    |Collation                                                                             |
|    |How the column is sorted in the index. In MySQL, this can have values A (Ascending) or|
|    |NULL (Not sorted).                                                                    |
|    |                                                                                      |
|    |Cardinality                                                                           |
|    |Number of unique values in the index. This is updated by running isamchk -a.          |
|    |                                                                                      |
|    |Sub_part                                                                              |
|    |Number of indexed characters if the column is only partly indexed. NULL if the entire |
|    |key is indexed.                                                                       |
|    |                                                                                      |
|    |SHOW STATUS fournit des informations sur le serveur (tout comme mysqladmin            |
|    |extended-status). Les informations fournies sont présentées ci-dessous. Le format et  |
|    |les nombres peuvent varier :                                                          |
|    |                                                                                      |
|    |+--------------------------+--------+                                                 |
|    || Variable_name            | Value  |                                                 |
|    |+--------------------------+--------+                                                 |
|    || Aborted_clients          | 0      |                                                 |
|    || Aborted_connects         | 0      |                                                 |
|    || Created_tmp_tables       | 0      |                                                 |
|    || Delayed_insert_threads   | 0      |                                                 |
|    || Delayed_writes           | 0      |                                                 |
|    || Delayed_errors           | 0      |                                                 |
|    || Flush_commands           | 2      |                                                 |
|    || Handler_delete           | 2      |                                                 |
|    || Handler_read_first       | 0      |                                                 |
|    || Handler_read_key         | 1      |                                                 |
|    || Handler_read_next        | 0      |                                                 |
|    || Handler_read_rnd         | 35     |                                                 |
|    || Handler_update           | 0      |                                                 |
|    || Handler_write            | 2      |                                                 |
|    || Key_blocks_used          | 0      |                                                 |
|    || Key_read_requests        | 0      |                                                 |
|    || Key_reads                | 0      |                                                 |
|    || Key_write_requests       | 0      |                                                 |
|    || Key_writes               | 0      |                                                 |
|    || Max_used_connections     | 1      |                                                 |
|    || Not_flushed_key_blocks   | 0      |                                                 |
|    || Not_flushed_delayed_rows | 0      |                                                 |
|    || Open_tables              | 1      |                                                 |
|    || Open_files               | 2      |                                                 |
|    || Open_streams             | 0      |                                                 |
|    || Opened_tables            | 11     |                                                 |
|    || Questions                | 14     |                                                 |
|    || Running_threads          | 1      |                                                 |
|    || Slow_requêtes            | 0      |                                                 |
|    || Uptime                   | 149111 |                                                 |
|    |+--------------------------+--------+                                                 |
|    |Les variables ci-dessus ont les significations suivantes :                            |
|    |Aborted_clients                                                                       |
|    |Number of connections that has been aborted because the client has died without       |
|    |closing the connection properly.                                                      |
|    |                                                                                      |
|    |Aborted_connects                                                                      |
|    |Number of tries to connect to the MySQL server that has failed.                       |
|    |                                                                                      |
|    |Created_tmp_tables                                                                    |
|    |Number of implicit temporary tables that has been created while executing statements. |
|    |                                                                                      |
|    |Delayed_insert_threads                                                                |
|    |Number of delayed insert handler threads in use.                                      |
|    |                                                                                      |
|    |Delayed_writes                                                                        |
|    |Number of rows written with INSERT DELAYED.                                           |
|    |                                                                                      |
|    |Delayed_errors                                                                        |
|    |Number of rows written with INSERT DELAYED for which some error occurred (probably    |
|    |duplicate key).                                                                       |
|    |                                                                                      |
|    |Flush_commands                                                                        |
|    |Number of executed FLUSH commands.                                                    |
|    |                                                                                      |
|    |Handler_delete                                                                        |
|    |Number of requests to delete a row from a table.                                      |
|    |                                                                                      |
|    |Handler_read_first                                                                    |
|    |Number of request to read first the row in a table.                                   |
|    |                                                                                      |
|    |Handler_read_key                                                                      |
|    |Number of request to read a row based on a key.                                       |
|    |                                                                                      |
|    |Handler_read_next                                                                     |
|    |Number of request to read next row in key order.                                      |
|    |                                                                                      |
|    |Handler_read_rnd                                                                      |
|    |Number of request to read a row based on a fixed position.                            |
|    |                                                                                      |
|    |Handler_update                                                                        |
|    |Number of requests to update a row in a table.                                        |
|    |                                                                                      |
|    |Handler_write                                                                         |
|    |Number of requests to insert a row in a table.                                        |
|    |                                                                                      |
|    |Key_blocks_used                                                                       |
|    |The number of used blocks in the key cache.                                           |
|    |                                                                                      |
|    |Key_read_requests                                                                     |
|    |The number of request to read a key block from the cache.                             |
|    |                                                                                      |
|    |Key_reads                                                                             |
|    |The number of physical reads of a key block from disk.                                |
|    |                                                                                      |
|    |Key_write_requests                                                                    |
|    |The number of request to write a key block to the cache.                              |
|    |                                                                                      |
|    |Key_writes                                                                            |
|    |The number of physical writes of a key block to disk.                                 |
|    |                                                                                      |
|    |Max_used_connections                                                                  |
|    |The maximum number of connections that has been in use simultaneously.                |
|    |                                                                                      |
|    |Not_flushed_key_blocks                                                                |
|    |Keys blocks in the key cache that has changed but hasn't yet been flushed to disk.    |
|    |                                                                                      |
|    |Not_flushed_delayed_rows                                                              |
|    |Number of rows waiting to be written in INSERT DELAY queues.                          |
|    |                                                                                      |
|    |Open_tables                                                                           |
|    |Number of tables that are open.                                                       |
|    |                                                                                      |
|    |Open_files                                                                            |
|    |Number of files that are open.                                                        |
|    |                                                                                      |
|    |Open_streams                                                                          |
|    |Number of streams that are open (used mainly for logging)                             |
|    |                                                                                      |
|    |Opened_tables                                                                         |
|    |Number of tables that has been opened.                                                |
|    |                                                                                      |
|    |Questions                                                                             |
|    |Number of questions asked from to the server.                                         |
|    |                                                                                      |
|    |Running_threads                                                                       |
|    |Number of currently open connections.                                                 |
|    |                                                                                      |
|    |Slow_queries                                                                          |
|    |Number of requêtesthat has taken more than long_query_time                            |
|    |                                                                                      |
|    |Uptime                                                                                |
|    |How many seconds the server has been up.                                              |
|    |                                                                                      |
|    |Commentaires :                                                                        |
|    |Si Opened_tables est grand, alors table_cache est probablement trop petit.            |
|    |Si key_reads est trop grand, alors key_cache est probablement trop petit. Le taux     |
|    |d'accès au cache est calculé avec la key_reads/key_read_requests.                     |
|    |Si Handler_read_rnd est grand, alors il y a probablement trop de requêtes qui obligent|
|    |MySQL a scanner des tables entières, ou il y a des commandes join qui n'utilisent pas |
|    |les clés à bon escient.                                                               |
|    |SHOW VARIABLES affiche quelques variables système de MySQL. Cette commande est        |
|    |disponible avec l'utilitaire mysqladmin variables command. Si les valeurs par défaut  |
|    |ne conviennent pas, il faut faire les réglages au démarrage, dans la commande de      |
|    |mysqld . Les informations fournit sont les suivantes, et ressemble fort au tableau    |
|    |ci-dessous :                                                                          |
|    |                                                                                      |
|    |+------------------------+--------------------------+                                 |
|    || Variable_name          | Value                    |                                 |
|    |+------------------------+--------------------------+                                 |
|    || back_log               | 5                        |                                 |
|    || connect_timeout        | 5                        |                                 |
|    || basedir                | /my/monty/               |                                 |
|    || datadir                | /my/monty/data/          |                                 |
|    || delayed_insert_limit   | 100                      |                                 |
|    || delayed_insert_timeout | 300                      |                                 |
|    || delayed_queue_size     | 1000                     |                                 |
|    || join_buffer_size       | 131072                   |                                 |
|    || flush_time             | 0                        |                                 |
|    || key_buffer_size        | 1048540                  |                                 |
|    || language               | /my/monty/share/english/ |                                 |
|    || log                    | OFF                      |                                 |
|    || log_update             | OFF                      |                                 |
|    || long_query_time        | 10                       |                                 |
|    || low_priority_updates   | OFF                      |                                 |
|    || max_allowed_packet     | 1048576                  |                                 |
|    || max_connections        | 100                      |                                 |
|    || max_connect_errors     | 10                       |                                 |
|    || max_delayed_threads    | 20                       |                                 |
|    || max_heap_table_size    | 16777216                 |                                 |
|    || max_join_size          | 4294967295               |                                 |
|    || max_sort_longueur      | 1024                     |                                 |
|    || max_tmp_tables         | 32                       |                                 |
|    || net_buffer_longueur    | 16384                    |                                 |
|    || port                   | 3306                     |                                 |
|    || protocol-version       | 10                       |                                 |
|    || record_buffer          | 131072                   |                                 |
|    || skip_locking           | ON                       |                                 |
|    || socket                 | /tmp/mysql.sock          |                                 |
|    || sort_buffer            | 2097116                  |                                 |
|    || table_cache            | 64                       |                                 |
|    || thread_stack           | 131072                   |                                 |
|    || tmp_table_size         | 1048576                  |                                 |
|    || tmpdir                 | /machine/tmp/            |                                 |
|    || version                | 3.23.0-alpha-debug       |                                 |
|    || wait_timeout           | 28800                    |                                 |
|    |+------------------------+--------------------------+                                 |
|    |Server parameters.                                                                    |
|    |SHOW PROCESSLIST affiche la liste des processus en ligne. Cette commande est aussi    |
|    |disponible avec la mysqladmin processlist. Avec les droits de process, tous les       |
|    |threads sont visibles. Sinon, seuls les threads utilisateurs sont visibles . KILL.    |
|    |KILL.                                                                                 |
|    |7.21 EXPLAIN (Détails sur SELECT)                                                     |
|    |                                                                                      |
|    |EXPLAIN SELECT select_options                                                         |
|    |L'option EXPLAIN force MySQL à expliquer la façon avec laquelle il va traiter la      |
|    |requête SELECT, en détaillant les opérations de regroupement.                         |
|    |Avec ces informations, il est possible de determiner les tables qui requièrent des    |
|    |indexes pour accélerer les SELECT, ainsi que l'ordre optimal dans lequel les tables   |
|    |reseront regroupées. Pour obliger l'optimiseur à respecter l'ordre de regroupement, il|
|    |suffit d'ajouter l'option STRAIGHT_JOIN.                                              |
|    |Pour les regroupements complexes, EXPLAIN retourne une ligne d'informations pour      |
|    |chaque table utilisée par la commande SELECT. Les tables sont listées dans l'ordre de |
|    |lecture. MySQL résoud les regroupements en utilisant une méthode d'aggrégation en un  |
|    |seul passage. Cela signifie que MySQL lit une ligne de la première table, puis il     |
|    |recherche les lignes correspondantes dans la seconde table, et ainsi de suite jusqu'à |
|    |la dernière table. Quand toutes les tables ont été traitées, il retourne la ligne     |
|    |selectionnée, et remonte progressivement jusqu'à la table initiale. Puis, la ligne    |
|    |suivante est selectionnée, et le processus continue avec la ligne suivante.           |
|    |La réponse de EXPLAIN inclus les colonnes suivantes :                                 |
|    |•  table La table qui est utilisée par la commande.                                   |
|    |•  type Le type de regroupement. Le détails sur les différents types est donnés plus  |
|    |bas.                                                                                  |
|    |•  possible_keys Les possible_keys indiques quels index MySQL peut utiliser pour      |
|    |rechercher des lignes dans la table. Si la colonne est vide, il n'y a pas d'index.    |
|    |Dans ce cas, il est surement possible d'améliorer les performances de la requête en   |
|    |éxaminant la clause WHERE pour voir quelles colonnes sont utilisées, et quelles       |
|    |colonnes mériteraient un indexage. Dans ce cas, il suffit de créer l'index adéquat, et|
|    |de reverifier la requête avec EXPLAIN . Pour voir quels sont les index disponibles    |
|    |pour une table, il faut utiliser la commande SHOW INDEX FROM Nom_table.               |
|    |•  key La colonne clé indique quelle clé MySQL a décidé d'utiliser. La clé est NULLsi |
|    |aucun index n'est choisi.                                                             |
|    |•  key_len key_len indique la longueur de la clé que a décidé d'utiliser. La longueur |
|    |sera NULL si la clé est NULL.                                                         |
|    |•  ref ref est le ou les numéros de colonne ou constantes utilisée avec la clé pour   |
|    |rechercher les lignes dans la table.                                                  |
|    |•  rows rows indique le nmbre de ligne que MySQL doit examiner pour éxécuter la       |
|    |requête.                                                                              |
|    |•  Extra Si la colonne inclus le texte Only index , cela signifie que les informaions |
|    |sont renvoyées par la table en utilisant uniquement l'index. Généralement, c'est      |
|    |beaucoup plus rapide que de scanner la table entière. Si cette colonne contient le    |
|    |texte where used, cela signifie que la clause WHERE a été utilisée pour restreindre le|
|    |nombre de ligne à retourner au client.                                                |
|    |Voici maintenant la liste des différents types de regroupement, du plus efficace au   |
|    |moins efficace :                                                                      |
|    |•  system La table n'a qu'une seule ligne (= table système). C'est un cas spécial de  |
|    |regroupement de type const.                                                           |
|    |•  const La table a au maximum une ligne à traiter, qui sera lue au début de la       |
|    |requête. Etant donné qu'il n'y a qu'une seule ligne, les valeurs de cette ligne       |
|    |peuvent être considérées comme des constantes pour l'optimisateur. Les tables de type |
|    |const sont extrêmement rapide à lire!                                                 |
|    |•  eq_ref Une ligne sera lue de cette table pour chaque combinaisons de ligne des     |
|    |tables précédentes. C'est le meilleur type de regroupement possible, en dehors du type|
|    |const. Il sera utilissé lorsque toutes les colonnes d'un index sont utilisées par un  |
|    |regroupement, et que l'index est UNIQUE ou PRIMARY KEY.                               |
|    |•  ref Toutes les lignes qui correspondent aux valeurs de l'index seront lues dans    |
|    |cette table, pour chaque combinaison de lignes des tables précédentes. ref est utilisé|
|    |si le regroupement utilise un préfixe comme clé, ou si la clé n'est pas UNIQUE ou     |
|    |PRIMARY KEY( en d'autres termes, si le regroupement ne peut pas sectionner une ligne  |
|    |unique à partir de la clé). Si la clé qui est utilisée ne rassemble que très peu de   |
|    |lignes, le regroupement est bon.                                                      |
|    |•  range Seules les lignes dans l'intervalle considéré seront renvoyée, en utilisant  |
|    |un index pour selectionner les lignes. La colonne ref indiquera quelles index sera    |
|    |utilisé.                                                                              |
|    |•  index Ce type est indentique à ALL, sauf que seul l'index est scanné. C'est        |
|    |généralement plus rapide que le type ALL, car un fichier d'index est généralement plus|
|    |petit que le fichier de données.                                                      |
|    |•  ALL Une recherche sur la table complète va être faite, pour chaque combinaison des |
|    |tables précédentes. C'est généralement très mauvais si la première table n'est pas    |
|    |marquée const, et encore plus mauvais dans les autres cas. On peut éviter d'utiliser  |
|    |ce mode de recherche en ajoutant des index, afin de transformer les lignes en         |
|    |constantes.                                                                           |
|    |Un bon critère pour evaluer l'efficacité d'un regroupement est de multiplier toutes   |
|    |les valeurs dans la colonne rows d'une requête avec EXPLAIN. Cela mesure              |
|    |approximativement le nombre de ligne que MySQL doit examiner pour résoudre la requête.|
|    |Ce nombre sera aussi utilisé pour restreindre la taille du regroupement, avec         |
|    |max_join_size.                                                                        |
|    |L'exemple suivant montre comme une clause peut être optimisée progressivement gr?ce   |
|    |aux informations fournies par EXPLAIN. On supposera que l'on souhaite exécuter la     |
|    |commande SELECTci-dessous, et qu'on l'examine avec EXPLAIN:                           |
|    |                                                                                      |
|    |EXPLAIN SELECT tt.TicketNumber, tt.TimeIn,                                            |
|    |tt.ProjectReference, tt.EstimatedShipDate,                                            |
|    |tt.ActualShipDate, tt.ClientID,                                                       |
|    |tt.ServiceCodes, tt.RepetitiveID,                                                     |
|    |tt.CurrentProcess, tt.CurrentDPPerson,                                                |
|    |tt.RecordVolume, tt.DPPrinted, et.COUNTRY,                                            |
|    |et_1.COUNTRY, do.CUSTNAME                                                             |
|    |FROM tt, et, et AS et_1, do                                                           |
|    |WHERE tt.SubmitTime IS NULL                                                           |
|    |AND tt.ActualPC = et.EMPLOYID                                                         |
|    |AND tt.AssignedPC = et_1.EMPLOYID                                                     |
|    |AND tt.ClientID = do.CUSTNMBR;                                                        |
|    |Pour cet exemple, on supposera par hypothèse :                                        |
|    |Les colonnes comparées sont déclarées comme suit :                                    |
|    |Table                                                                                 |
|    |Column                                                                                |
|    |Column type                                                                           |
|    |                                                                                      |
|    |tt                                                                                    |
|    |ActualPC                                                                              |
|    |CHAR(10)                                                                              |
|    |                                                                                      |
|    |tt                                                                                    |
|    |AssignedPC                                                                            |
|    |CHAR(10)                                                                              |
|    |                                                                                      |
|    |tt                                                                                    |
|    |ClientID                                                                              |
|    |CHAR(10)                                                                              |
|    |                                                                                      |
|    |et                                                                                    |
|    |EMPLOYID                                                                              |
|    |CHAR(15)                                                                              |
|    |                                                                                      |
|    |do                                                                                    |
|    |CUSTNMBR                                                                              |
|    |CHAR(15)                                                                              |
|    |                                                                                      |
|    |Les tables ont les index suivants :                                                   |
|    |Table                                                                                 |
|    |Index                                                                                 |
|    |                                                                                      |
|    |tt                                                                                    |
|    |ActualPC                                                                              |
|    |                                                                                      |
|    |tt                                                                                    |
|    |AssignedPC                                                                            |
|    |                                                                                      |
|    |tt                                                                                    |
|    |ClientID                                                                              |
|    |                                                                                      |
|    |et                                                                                    |
|    |EMPLOYID (primary key)                                                                |
|    |                                                                                      |
|    |do                                                                                    |
|    |CUSTNMBR (primary key)                                                                |
|    |                                                                                      |
|    |Les valeurs de tt.ActualPC n'ont pas encore été assignées.                            |
|    |Au démarrage, avant la moindre optimisation, la clause produit la réponse suivante :  |
|    |                                                                                      |
|    |table type possible_keys                key  key_len ref  rows  Extra                 |
|    |et    ALL  PRIMARY                      NULL NULL    NULL 74                          |
|    |do    ALL  PRIMARY                      NULL NULL    NULL 2135                        |
|    |et_1  ALL  PRIMARY                      NULL NULL    NULL 74                          |
|    |tt    ALL  AssignedPC,ClientID,ActualPC NULL NULL    NULL 3872                        |
|    |range checked for each record (key map: 35)                                           |
|    |Etant donné que le type de regroupement est ALL pour toutes les tables, ces           |
|    |informations indique que MySQLfait un regroupement sur toutes les tables! Cela va     |
|    |prendre un temps énorme, vu le nombre de lignes à étudier dans chaque table. Pour le  |
|    |cas présent, cela représente 74 * 2135 * 74 * 3872 = 45,268,558,720 rows. Et encore,  |
|    |ces tables pourraient être encore plus grosses...                                     |
|    |Un des problèmes posés ici est que MySQL ne peut pas encore (encore) utiliser d'index |
|    |pour des colonnes déclarées de manière différentes. Dans l'exemple, VARCHAR et CHAR   |
|    |sont identiques, à moins qu'ils ne soient déclarés sur des longueurs différentes. Or, |
|    |tt.ActualPC est de type CHAR(10) et et.EMPLOYID est de type CHAR(15) : les longueur ne|
|    |concordent pas.                                                                       |
|    |Pour consolider la base, on utilise la commande ALTER TABLE pour rallonger le champs  |
|    |ActualPC de 10 caractères à 15 caractères:                                            |
|    |                                                                                      |
|    |mysql> ALTER TABLE tt MODIFY ActualPC VARCHAR(15);                                    |
|    |Maintenant, tt.ActualPC et et.EMPLOYID sont tous les deux de type VARCHAR(15).        |
|    |L'éxecution de la commande EXPLAIN produit maintenant le résultat suivant :           |
|    |                                                                                      |
|    |table type   possible_keys   key     key_len ref         rows    Extra                |
|    |tt    ALL    AssignedPC,ClientID,ActualPC NULL NULL NULL 3872    where used           |
|    |do    ALL    PRIMARY         NULL    NULL    NULL        2135                         |
|    |range checked for each record (key map: 1)                                            |
|    |et_1  ALL    PRIMARY         NULL    NULL    NULL        74                           |
|    |range checked for each record (key map: 1)                                            |
|    |et    eq_ref PRIMARY         PRIMARY 15      tt.ActualPC 1                            |
|    |Ce n'est pas parfait, mais c'est nettement mieux (le produit des colonnes rows a été  |
|    |réduit d'un facteur 74). Cette version s'éxecute maintenant en quelques secondes.     |
|    |Une autre amélioration peut être apportée en éliminant les disparités de longueur     |
|    |entre les colonnes tt.AssignedPC et et_1.EMPLOYID, et d'autres part , tt.ClientID et  |
|    |do.CUSTNMBR comparisons:                                                              |
|    |                                                                                      |
|    |mysql> ALTER TABLE tt MODIFY AssignedPC VARCHAR(15),                                  |
|    |MODIFY ClientID   VARCHAR(15);                                                        |
|    |Maintenant EXPLAIN produit maintenant le résultat suivant :                           |
|    |                                                                                      |
|    |table type   possible_keys   key     key_len ref            rows     Extra            |
|    |et    ALL    PRIMARY         NULL    NULL    NULL           74                        |
|    |tt    ref    AssignedPC,ClientID,ActualPC ActualPC 15 et.EMPLOYID 52 where used       |
|    |et_1  eq_ref PRIMARY         PRIMARY 15      tt.AssignedPC  1                         |
|    |do    eq_ref PRIMARY         PRIMARY 15      tt.ClientID    1                         |
|    |C'est déjà très bien.                                                                 |
|    |Le problème final est que, par défaut, MySQL suppose que les valeurs dans la colonne  |
|    |tt.ActualPC sont réparties uniformément. Or, ce n'est pas le cas de la table tt.      |
|    |Heureusement, il est facile de le préciser à MySQL :                                  |
|    |                                                                                      |
|    |shell> isamchk --analyze PATH_TO_MYSQL_DATABASE/tt                                    |
|    |shell> mysqladmin refresh                                                             |
|    |Le résultat est maintenant parfait, et maintenant EXPLAIN produit maintenant le       |
|    |résultat suivant :                                                                    |
|    |                                                                                      |
|    |table type   possible_keys   key     key_len ref            rows    Extra             |
|    |tt    ALL    AssignedPC,ClientID,ActualPC NULL NULL NULL    3872    where used        |
|    |et    eq_ref PRIMARY         PRIMARY 15      tt.ActualPC    1                         |
|    |et_1  eq_ref PRIMARY         PRIMARY 15      tt.AssignedPC  1                         |
|    |do    eq_ref PRIMARY         PRIMARY 15      tt.ClientID    1                         |
|    |On peut noter que la colonne rows est une estimation de la part de l'optimisateur de  |
|    |regroupement de MySQL : pour optimiser une commande, il faudrait maintenant vérifier  |
|    |qu'elle a des chiffres proche de la vérité. Si non, il faudrait améliorer les         |
|    |performances avec la clause STRAIGHT_JOIN dans la commande SELECT, et essayer de      |
|    |proposer différents ordres pour la liste des tables .                                 |
|    |7.22 DESCRIBE (Informations sur les colonnes)                                         |
|    |                                                                                      |
|    |{DESCRIBE | DESC} Nom_table {Nom_col | wild}                                          |
|    |DESCRIBE fournit des informations à propos des colonnes d'une table. Nom_col peut être|
|    |un nom de colonne, ou une chaîne qui contenant le caractère spécial SQL ``%'' et ``_''|
|    |.                                                                                     |
|    |DESCRIBE fait la liste des colonnes d'une table. Si les types des colonnes sont       |
|    |différens de ce qui ont été spécifiés à la création, avec la CREATE TABLE, il faut    |
|    |savoir que parfois, MySQL change spontanément le type de colonnes. 7.6.1 Modifications|
|    |automatiques de type de colonne.                                                      |
|    |La commande USE est fournie pour assurer la compatibilité avec Oracle.                |
|    |La commande SHOW fournit les mêmes informations. SHOW.                                |
|    |7.23 LOCK TABLES/UNLOCK TABLES                                                        |
|    |                                                                                      |
|    |LOCK TABLES Nom_table [AS alias] {READ | [LOW_PRIORITY] WRITE}                        |
|    |[, Nom_table {READ | [LOW_PRIORITY] WRITE} ...]                                       |
|    |...                                                                                   |
|    |UNLOCK TABLES                                                                         |
|    |LOCK TABLES verrouille une table dans le thread courant. UNLOCK TABLES ouvre tous les |
|    |verrous posé par le thread courant. Toutes les tables verrouillé par un thread sont   |
|    |automatiquement déverrouillée quand le thread émet un autre LOCK TABLES, ou à la fin  |
|    |de la connexion au serveur.                                                           |
|    |Si un thread obtiens le verrou de lecture (READ) sur une table, le thread (et tous les|
|    |autres threads) ne peut que lire dans la table. Si un thread obtiens e verrou de      |
|    |lecture (READ) sur une table, le thread qui a le verrous est le seul à pouvoir lire ou|
|    |écrire dans la table.                                                                 |
|    |Les autres threads attendent (sans limite) que le verrous se libère.                  |
|    |Le verrous d'écriture a une priorité supérieure au verrou de lecture, afin que les    |
|    |processus de mise à jour puisse se faire dès que possible. Cela signifie que si un    |
|    |thread obtiens un verrou de lecture, et qu'un autre thread obtiens un verrou          |
|    |d'écriture, alors le thread au verrou de lecture devra attendre la libération du      |
|    |verrou d'écriture. Il est possible d'utiliser des verrous d'écriture de basse priorité|
|    |(LOW_PRIORITY WRITE), mais il faut être sur qu'il y aura un moment ou aucun thread ne |
|    |sera en train de lire la table.                                                       |
|    |Lors de l'utilisation de la commande LOCK TABLES, il faut verrouiller toutes les      |
|    |tables qui vont être utilisées. Si il y a des alias dans une requête, il faut aussi   |
|    |avoir les verrous pour les alias! Cette politique assure que la table ne se verrouille|
|    |jamais, sans pouvoir être déverrouillée.                                              |
|    |Il ne faut jamais verrouiller une table qui va accepter une insertion reportée (INSERT|
|    |DELAYED). Car, dans ce cas, l'insertion sera faite dans un autre thread, qui n'aura   |
|    |pas le verrou.                                                                        |
|    |Généralement, il n'y a pas besoin de verrouiller les tables, car les mise à jour      |
|    |UPDATE sont atomiques : aucun autre thread ne peut interférer avec la commande en     |
|    |cours d'éxécution. Il y a toutes fois, quelques cas où il est bon de verrouiller une  |
|    |table :                                                                               |
|    |Si un grand nombre d'opération vont être menée sur un bon nombre de table, il est plus|
|    |rapide de verrouiller les tables utilisées. L'inconvénient, bien sur, est qu'aucun    |
|    |autre thread ne pourra accèder aux informations, ni les modifier.                     |
|    |MySQL ne supporte pas d'environnement transactionnel, donc il faut absolument         |
|    |verrouiller une table, pour s'assurer qu'au autre thread n'intervient entre une       |
|    |commande SELECT et une commande UPDATE . L'exemple ci-dessous montre comment exécuter |
|    |une transaction :                                                                     |
|    |                                                                                      |
|    |                                                                                      |
|    |mysql> LOCK TABLES trans READ, customer WRITE;                                        |
|    |mysql> select sum(value) from trans where customer_id= some_id;                       |
|    |mysql> update customer set total_value=sum_from_previous_statement                    |
|    |where customer_id=some_id;                                                            |
|    |mysql> UNLOCK TABLES;                                                                 |
|    |Sans la commande LOCK TABLES, il se peut qu'un autre thread insère une nouvelle ligne |
|    |dans la table trans entre les deux commandes SELECT et UPDATE .                       |
|    |En utilisant des modifications incrémentales (UPDATE customer SET                     |
|    |value=value+new_value) ou avec la commande LAST_INSERT_ID(), on peut généralement     |
|    |éviter l'utilisation des LOCK TABLES.                                                 |
|    |Il est aussi possible de résoudre quelques cas en utilisant les verrous utilisateurs  |
|    |GET_LOCK() et RELEASE_LOCK(). Ces verrous sont sauvés dans une table du serveur, et   |
|    |programmé avec pthread_mutex_lock() et pthread_mutex_unlock() pour plus de rapidité.n |
|    |Miscellaneous functions. 10.11 Comment MySQL verrouille les tables.                   |
|    |7.24 SET OPTION                                                                       |
|    |                                                                                      |
|    |SET [OPTION] SQL_VALUE_OPTION= value, ...                                             |
|    |SET OPTION selectionne différentes options qui affecteront le mode opératoire du      |
|    |client ou du serveur. Toute option reste valable jusqu'à la fin de la session, ou     |
|    |jusqu'à la prochaine modification.                                                    |
|    |•  •  CHARACTER SET character_set_name | DEFAULT Cette option permet de choisir la    |
|    |table des caractères utilisée par MySQL. Actuellement, la seule option possible est   |
|    |cp1251_koi8, mais il est très simple d'ajouter de nouvelles tables en éditant le      |
|    |fichier ``sql/convert.cc'' dans le code source de MySQL . La table par défaut peut    |
|    |être rappelée en utilisant la valeur DEFAULT. Il faut noter que la syntaxe pour       |
|    |choisir la table de caractère est différente des autres.                              |
|    |•  PASSWORD = PASSWORD('some password') Choisit un nouveau mot de passe pour          |
|    |l'utilisateur courant. Tout utilisateur non-anonyme peut changer son mot de passe!    |
|    |•  PASSWORD FOR user = PASSWORD('some password') Assigne un nouveau mot de passe pour |
|    |un utilisateur du serveur courant. Seul, un utilisateur avec des droits d'accès à     |
|    |mysql database peut le faire. L'utilisateur modifié doit être désigné par             |
|    |utilisateur@nom_hote , avec utilisateur et nom_hote qui prennent les valeurs qui      |
|    |apparaissent dans la tablemysql.user, sous les colonnes User et Host columns of the   |
|    |table entry. Par exemple, si il existe une ligne avec User et Host qu valent          |
|    |respectivement 'bob' et '%.loc.gov', il faudra écrire:                                |
|    |                                                                                      |
|    |mysql> SET PASSWORD FOR bob@"%.loc.gov" = PASSWORD("newpass");                        |
|    |•  SQL_BIG_TABLES = 0 | 1 Si mis à un, toutes les tables temporaires sont stockés sur |
|    |le disque dur, plutôt qu'en mémoire. Cela rend le processus un peu plus lent, mais il |
|    |génère pas d'erreur du type The table Nom_table is full (la table Nom_table est       |
|    |pleine), si de grosses commandes SELECT demandes de grandes tables temporaires. Par   |
|    |défaut, cette option est à 0.                                                         |
|    |•  SQL_BIG_SELECTS = 0 | 1 Si mis à 1, MySQL annulera une commande SELECT qui va      |
|    |prendre un temps trop long. Ceci est très utile quand une clause WHERE complexe a été |
|    |spécifiée. Une requête trop long est une commande SELECT qui va avoir à étudier plus  |
|    |de max_join_size rows lignes. Par défaut, cette valeur est à 0 (Toutes les commandes  |
|    |SELECT autorisées).                                                                   |
|    |•  SQL_LOW_PRIORITY_UPDATES = 0 | 1 Si mis à 1, toutes les commandes INSERT, UPDATE et|
|    |DELETE attendent qu'il n'y ait plus de commande SELECT en attente sur la table        |
|    |affectée.                                                                             |
|    |•  SQL_SELECT_LIMIT = value | DEFAULT Le nombre maximal de ligne à retourner dans une |
|    |commande SELECT. Si une commande SELECT a une clause de limite LIMIT, LIMIT est       |
|    |prioritaire sur SQL_SELECT_LIMIT. La valeur par défaut pour cette option est "sans    |
|    |limite". Si la limite a été changée, il est toujours possible de restaurer la         |
|    |configuration initiale avec DEFAULT.                                                  |
|    |•  SQL_LOG_OFF = 0 | 1 Si mis à 1, aucun historique ne sera transmis au client, si le |
|    |client a les droits de process . Ceci n'affecte pas l'historique de mise à jour.      |
|    |•  SQL_LOG_UPDATE = 0 | 1 Si mis à 0, aucun historique de modification ne sera tenu,  |
|    |si le client a les droits de process privilege. Ceci n'affecte pas l'historique du    |
|    |client.                                                                               |
|    |•  TIMESTAMP = timestamp_value | DEFAULT Met à l'heure le client. Cette fonction est  |
|    |généralement utilisée pour fixer la valeur initiale du timestamp, lors de             |
|    |l'utilisation de l'historique pour recréer des lignes.                                |
|    |•  LAST_INSERT_ID = # Fixe la valeur qui sera retournée par la prochaine fonction     |
|    |LAST_INSERT_ID(). Elle est stockée dans l'historique de modification.                 |
|    |•  INSERT_ID = # Fixe la prochaine valeur à utiliser lors d'une insertion dans une    |
|    |table avec une colonne de type AUTO_INCREMENT value. Cela sert surtout avec           |
|    |l'historique de modifications.                                                        |
|    |7.25 GRANT et REVOKE                                                                  |
|    |                                                                                      |
|    |GRANT priv_type [(column_list)] [, priv_type [(column_list)] ...]                     |
|    |ON {Nom_table | * | *.* | Nom_bdd.*}                                                  |
|    |TO user_name [IDENTIFIED BY 'password']                                               |
|    |[, user_name [IDENTIFIED BY 'password'] ...]                                          |
|    |[WITH GRANT OPTION]                                                                   |
|    |REVOKE priv_type [(column_list)] [, priv_type [(column_list)] ...]                    |
|    |ON {Nom_table | * | *.* | Nom_bdd.*}                                                  |
|    |FROM user_name [, user_name ...]                                                      |
|    |GRANT est implémenté depuis la version 3.22.11de MySQL. Pour les ancienne versions, la|
|    |commande GRANT ne fait rien.                                                          |
|    |Les commandes GRANT et REVOKE permettent aux administrateurs système de donner et     |
|    |enlever des droits aux utilisateurs :                                                 |
|    |•  niveau général (Global level) : Les droits de niveau général s'applique à toutes   |
|    |les bases de données du serveur. Ces droits sont stocké dans la table mysql.user.     |
|    |•  Niveau base de données (Database level): Les droits de niveau base de données      |
|    |s'applique aux tables d'une base de données. Ces droits sont stockés dans les tables  |
|    |mysql.db et mysql.host.                                                               |
|    |•  Niveau table (Table level) : Les droits de niveau table s'appliquent aux colonnes  |
|    |d'une table donnée. apply to all columns in a given table. Ces droits sont stockés    |
|    |dans la table mysql.tables_priv .                                                     |
|    |•  Niveu colonne (Column level) : Les droits de niveau colonne s'appliquent à une     |
|    |colonn donnée d'une table donnée. to single columns in a given table. Ces droits sont |
|    |stockés dans la table mysql.columns_priv .                                            |
|    |Les commandes GRANT et REVOKE peuvent s'appliquer aux droits suivants, précisés dans  |
|    |priv_type:                                                                            |
|    |                                                                                      |
|    |ALL PRIVILEGES      FILE                RELOAD                                        |
|    |ALTER               INDEX               SELECT                                        |
|    |CREATE              INSERT              SHUTDOWN                                      |
|    |DELETE              PROCESS             UPDATE                                        |
|    |DROP                REFERENCES          USAGE                                         |
|    |ALL est un synonyme de for ALL PRIVILEGES. REFERENCES n'est pas encore implémenté.    |
|    |USAGE est actuellement synonyme de ``aucun droits''.Il peut être utilisé pour créer un|
|    |utilisateur sans droits.                                                              |
|    |Pour enlever le droit de grant d'un utilisateur, il faut utiliser la valeur suivante  |
|    |dans priv_type :                                                                      |
|    |                                                                                      |
|    |                                                                                      |
|    |REVOKE GRANT OPTION ON ... FROM ...;                                                  |
|    |Les seules valeurs de priv_type qu'il est possible de spécifier sont SELECT, INSERT,  |
|    |UPDATE, DELETE, CREATE, DROP, GRANT, INDEX et ALTER.                                  |
|    |Les seules valeurs de priv_type qu'il est possible de spécifier pour une colonne      |
|    |(c'est à dire, en utilisant la clause column_list) sont SELECT, INSERT et UPDATE.     |
|    |Il est possible de donner les droits généraux en utilisant la syntaxe ON *.* . Il est |
|    |possible de donner des droits sur une base de données en utilisant la syntaxe ON      |
|    |Nom_bdd.* syntax. Si il y a une base de données courante, et que l'on spécifie ON *,  |
|    |cela revient à donner tous les droits pour la base de données courante . (Attention:  |
|    |Si il n'y a pas de base de données courante, cela revient à donner des droits sur le  |
|    |serveur entier! )                                                                     |
|    |Afin de pouvoir donner des droits à des utilisateurs d'hotes divers et variés, MySQL  |
|    |accepte la spécification de l'utilisateur sous la forme user@host. Pour pouvoir       |
|    |spécifier des noms d'utilisateur ou d'hotes ayant des caractères spéciaux dans le nom |
|    |(comme ``-''), il suffit d'entourer le nom de l'utilisateur ou de l'hote de guillemets|
|    |simples (i.e., 'test-user''test-hostname').                                           |
|    |Les noms d'hotes peuvent avoir des caractères jokers : Par exemple, user@"%.loc.gov"  |
|    |s'applique à tous les utilisateurs user pour tous les hotes du domaine loc.gov et     |
|    |user@"144.155.166.%" s'appliquera à tous les user pour des hotes dans le domaine      |
|    |144.155.166 .                                                                         |
|    |La forme simplifié user est un synonyme de user@"%". Note: pour autoriser des         |
|    |utilisateurs anonymes sur le serveur MySQL (ce qui est le comportement par défaut), il|
|    |faut aussi ajouter les utilisateurs locaux, gr?ce à la forme user@localhost car sinon,|
|    |la ligne pour l'utilisateur anonyme dans la table mysql.user sera utilisée quand      |
|    |l'utilisateur essaiera de se connecter à MySQL depuis la machine locale! Les          |
|    |utilisateurs anonymes sont définis en insérant une ligne User='' dans la table        |
|    |mysql.user . On peut vérifier si cela s'applique en exécutant la ligne suivante :     |
|    |                                                                                      |
|    |mysql> SELECT Host,User FROM mysql.user WHERE User='';                                |
|    |Pour le moment, la commande GRANT n'accepte que des hotes, tables, bases et colonnes  |
|    |dont le nom ne dépasse pas 60 caractères. Un nom d'utilisateur peut aller jusqu'à 16  |
|    |caractères.                                                                           |
|    |Les privilèges pour une table ou une colonne sont constitués du OU logique de chacun  |
|    |des droits. Par exemple, si la table mysql.user précise que un utilisateur a un droit |
|    |de select gloabal, cela ne peut pas être interdit par une entrée dans une base, une   |
|    |table ou une colonne.                                                                 |
|    |Les droits pour une colonne sont calculés comme suit :                                |
|    |                                                                                      |
|    |global privileges                                                                     |
|    |OR (database privileges AND host privileges)                                          |
|    |OR table privileges                                                                   |
|    |OR column privileges                                                                  |
|    |Dans la plupart des cas, les droits sont donnés aux utilisateurs avec les niveaux de  |
|    |droits, ce qui simplifie grandement la vie.                                           |
|    |Si des droits sont donnés à un couple user/hostname qui n'existe pas dans la table    |
|    |mysql.user, une entrée est insérée dans la table des droits, et elle reste valide     |
|    |jusqu'à ce qu'une commande DELETE l'efface. En d'autres termes, GRANT peut créer un   |
|    |utilisateur, mais REVOKE ne l'effacera pas. Il faut le faire explicitement avec       |
|    |DELETE.                                                                               |
|    |A partir de MySQL 3.22.12 , lors de la création d'un nouvel utilisateur ou avec les   |
|    |droits globaux, un mot de passe sera affecté avec la clause IDENTIFIED BY . Si        |
|    |l'utilisateur à déjà un mot de passe, il sera remplacé par le nouveau.                |
|    |Attention: Lors de la création d'un utilisateur, il aucun mot de passe n'est          |
|    |spécifiée, cet utilisateur n'aura pas de mot de passe. C'est très imprudent.          |
|    |Les mots de passe peuvent être assignés et modifiés avec la commande : SET PASSWORD . |
|    |SET OPTION.                                                                           |
|    |Lors de l'attribution de droit de niveau base , une entrée est ajoutée dans la table  |
|    |mysql.db, si nécessaire. Quand toutes les privilèges poue la base de données sont     |
|    |supprimés avec REVOKE, l'entrée est effacée.                                          |
|    |Si un utilisateur n'a aucun droit sur uen table, la table n'est pas affichée quand    |
|    |l'utilisateur fait une requête sur cette table. La table ne sera même pas visible avec|
|    |une commandes SHOW TABLES.                                                            |
|    |La clause WITH GRANT OPTION donne à l'utilisateur la capacité de donner à d'autres    |
|    |utilisateurs des droits, d'un niveau égal à ceux qu'il a déjà. Il faut être très      |
|    |prudent quand on attribue ce droit, car deux utilisateurs avec des droits différents  |
|    |peuvent rassembler leurs droits.                                                      |
|    |Il faut bien savoir que lorsqu'on donne à un utilisateur le droit de grant, tous les  |
|    |droits que possède cet utilisateur sont transmissible par cet utilisateur. Supposons  |
|    |que l'on ait donné des droits d'insertion à un utilisateur. Si on lui ajoute le droit |
|    |de select sur une base, et qu'on lui ajoute en plus WITH GRANT OPTION, l'utilisateur  |
|    |peut donner les droits de selection et d'insertion à tout autre utilisateur. Et si on |
|    |lui ajoute encore le droit de update, il pourra aussi donner ce droit.                |
|    |Il ne vaut mieux pas donner des droits de alter à un utilisateur normal. Dans ce cas, |
|    |l'utilisateur peut essayer de pirater le système en renommant les tables de droits du |
|    |système.                                                                              |
|    |Lors de l'utilisation des droits de table ou de colonne pour un utilisateur, le       |
|    |serveur examine les droits de table et de colonne pour tous les utilisateurs, et cela |
|    |ralentit légérement MySQL.                                                            |
|    |Quand mysqld démarre, tous les droits sont chargés en mémoire. Les droits de table,   |
|    |base et colonnes prennent effet aussitôt, et les droits d'utilisateur prennent effet à|
|    |la première connexion. Les modifications des tables de droits sont faites avec les    |
|    |fonctions GRANT et REVOKE et sont repercutées par le serveur immédiatement.Si les     |
|    |tables de droits sont modifiées à la main (avec INSERT, UPDATE, etc.), il faut        |
|    |exécuter une commande FLUSH PRIVILEGES ou lancer l'utilitaire mysqladmin              |
|    |flush-privileges pour faire prendre en compte des nouveaux droits.                    |
|    |Les différences les plus notables entre ANSI SQL et MySQL pour la commande GRANT sont:|
|    |                                                                                      |
|    |ANSI SQL n' pas de droit de nvieau global ou base de données, et ANSI SQL ne supporte |
|    |pas tous les types de droits de MySQL.                                                |
|    |Lors de l'effacement d'une table en ANSI SQL, tous les privilèges de cette table sont |
|    |révoqués. Lors de la révocation d'un droit avec ANSI SQL, tous les privilèges qui ont |
|    |été octroyés avec ce droits sont aussi révoqués. Avec MySQL, les droits peuvent être  |
|    |abandonnés uniquement avec la commande REVOKE ou en manipulant (avec précautions) les |
|    |tables de droits.                                                                     |
|    |7.26 CREATE INDEX                                                                     |
|    |                                                                                      |
|    |CREATE [UNIQUE] INDEX Nom_indexON Nom_table (Nom_col[(longueur]),... )                |
|    |The CREATE INDEX n'est disponible qu'à partir de la version 3.22. CREATE INDEX est un |
|    |raccourci de ALTER TABLE qui crée des index. ALTER TABLE                              |
|    |Généralement, il est possible de créer des tous les index d'une table au moment de la |
|    |création de la table, avec CREATE TABLE. CREATE TABLECREATE INDEX permettra alors     |
|    |d'ajouter de nouveaux index.                                                          |
|    |Une liste de nom de colonne de format (col1,col2,...) créer un index de multiples     |
|    |colonnes. Les index sont formés en concaténant les différentes valeurs en une ligne.  |
|    |Pour les valeurs de type CHAR et VARCHAR , les index peuvent ne prendre en compte     |
|    |qu'une partie de la colonne, en précisant Nom_col(longueur) . (Avec les types BLOB et |
|    |TEXT, cette longueur est obligatoire. ). La commande suivante montre comment créer un |
|    |index sur les 10 premiers caractères d'une colonne :                                  |
|    |                                                                                      |
|    |mysql> CREATE INDEX part_of_name ON customer (name(10));                              |
|    |Etant donné que la plus part des mots diffèrent les uns des autres dans les 10        |
|    |premières lettres, l'index crée ne devrait pas être moins efficace que la colonne,    |
|    |tout en étant nettement plus rapide. Faire des index à valeur partiel permet de       |
|    |réduire la taille des index, et d'accélérer les opération de tris et d'insertion.     |
|    |Il faut noter que l'on peut ajouter à un index une colonne qui accepte les types NULL,|
|    |que depuis la version 3.23.2 de MySQL. De même pour les colonnes de type BLOB/TEXT.   |
|    |Cela impose l'utilisation du format de table MyISAM.                                  |
|    |7.27 DROP INDEX                                                                       |
|    |                                                                                      |
|    |DROP INDEX Nom_index                                                                  |
|    |The DROP INDEX n'est disponible qu'à partir de la version 3.22. DROP INDEX est un     |
|    |raccourci de ALTER TABLE qui efface des index. ALTER TABLE ALTER TABLE.               |
|    |7.28 Commentaires                                                                     |
|    |Le serveur MySQL accepte les commentaires qui commencent par # jusqu'à la fin de la   |
|    |ligne, et les commentaires multi-lignes de type C/C++ /*........... */ :              |
|    |                                                                                      |
|    |mysql> select 1+1;     # This comment continues to the end of line                    |
|    |mysql> select 1 /* this is an in-line comment */ + 1;                                 |
|    |mysql> select 1+                                                                      |
|    |/*                                                                                    |
|    |this is a                                                                             |
|    |multiple-line comment                                                                 |
|    |*/                                                                                    |
|    |1;                                                                                    |
|    |Bien que le serveur comprennent les commentaires multi lignes, il y a quelques        |
|    |restrictions :                                                                        |
|    |Le guillemets, simple et doubles, sont considés comme indiquant le début d'une chaîne,|
|    |même à l'intérieur d'un commentaire. Si le guillement n'est pas doublé, l'analyseur ne|
|    |réalise par que le commentaires est terminé. Sous mysql , l'invite de commande passe  |
|    |de mysql> à '> or ">.                                                                 |
|    |Un point virgule est considéré comme une fin de commande SQL, et tout ce qui est après|
|    |est la prochaine commande.                                                            |
|    |Ces limitations s'applique aussi bien lors de l'utilsation de mysql que lors de la    |
|    |lecture d'un fichier dans une table.                                                  |
|    |MySQL n'accepte pas les commentaires de type ``--'' ANSI SQL. 5.3.7 `--' comme début  |
|    |de commentaire.                                                                       |
|    |7.29 CREATE FUNCTION/DROP FUNCTION                                                    |
|    |                                                                                      |
|    |CREATE FUNCTION function_name RETURNS {STRING|REAL|INTEGER}                           |
|    |SONAME shared_library_name                                                            |
|    |DROP FUNCTION function_name                                                           |
|    |Une fonction définie par l'utilisateur est un bon moyen d'ajouter de nouvelles        |
|    |fonctionnalités à MySQL avec de nouvelles fonctions natives, comme par exemple ABS()  |
|    |et CONCAT().                                                                          |
|    |CREATE FUNCTION sauve le nom de la fonction, le type et le point d'entrée de la       |
|    |fonction dans la table système mysql.func . Il faut avoir les droit insert et delete  |
|    |pour pouvoir créer et effacer des fonctions.                                          |
|    |Toutes les fonctions actives sont rechargées à chaque démarrage du serveur, à moins de|
|    |lancer mysqld avec l'option --skip-grant-tables . Dans ce cas, l'initialisation des   |
|    |fonctions utilisateurs est oubliée, et les fonctions sont inutilisables. (Une fonction|
|    |active est une fonction créée par CREATE FUNCTION et pas effacée avec DROP FUNCTION.) |
|    |7.30 Mots reservés par MySQL                                                          |
|    |Un problème commun est la création d'une table avec des noms de colonne qui sont aussi|
|    |des nom de type de données, ou de fonction natives MySQL. Ceci est parfaitement       |
|    |possible (par exemple, ABS peut être un nom de colonne), mais aucun espace n'est      |
|    |autorisé entre le nom d'une fonction est la parenthèse ouvrante lorsque ces noms sont |
|    |utilisé comme des fonctions .                                                         |
|    |Les mots suivants sont explicitement reservés par MySQL. La plus part sont interdits  |
|    |pas ANSI SQL92 comme nom de colonne ou nom de table (par exemple, group). Quelques uns|
|    |sont reservés par MySQL qui en a besoin pour utiliser un analyseur syntaxique yacc    |
|    |Les noms suivants (issus de la table ci-dessus) sont interdits pas ANSI SQL, mais     |
|    |acceptés apr MySQL comme nom de table/colonne. Ceci, car ces noms sont très courants, |
|    |et de nombreuses personnes les utilisent déjà :                                       |
|    |action                                                                                |
|    |add                                                                                   |
|    |all                                                                                   |
|    |alter                                                                                 |
|    |                                                                                      |
|    |after                                                                                 |
|    |and                                                                                   |
|    |as                                                                                    |
|    |asc                                                                                   |
|    |                                                                                      |
|    |auto_increment                                                                        |
|    |between                                                                               |
|    |bigint                                                                                |
|    |bit                                                                                   |
|    |                                                                                      |
|    |binary                                                                                |
|    |blob                                                                                  |
|    |bool                                                                                  |
|    |both                                                                                  |
|    |                                                                                      |
|    |by                                                                                    |
|    |cascade                                                                               |
|    |char                                                                                  |
|    |character                                                                             |
|    |                                                                                      |
|    |change                                                                                |
|    |check                                                                                 |
|    |column                                                                                |
|    |columns                                                                               |
|    |                                                                                      |
|    |constraint                                                                            |
|    |create                                                                                |
|    |cross                                                                                 |
|    |current_date                                                                          |
|    |                                                                                      |
|    |current_time                                                                          |
|    |current_timestamp                                                                     |
|    |data                                                                                  |
|    |database                                                                              |
|    |                                                                                      |
|    |databases                                                                             |
|    |date                                                                                  |
|    |datetime                                                                              |
|    |day                                                                                   |
|    |                                                                                      |
|    |day_hour                                                                              |
|    |day_minute                                                                            |
|    |day_second                                                                            |
|    |dayofmonth                                                                            |
|    |                                                                                      |
|    |dayofweek                                                                             |
|    |dayofyear                                                                             |
|    |dec                                                                                   |
|    |decimal                                                                               |
|    |                                                                                      |
|    |default                                                                               |
|    |delete                                                                                |
|    |desc                                                                                  |
|    |describe                                                                              |
|    |                                                                                      |
|    |distinct                                                                              |
|    |distinctrow                                                                           |
|    |double                                                                                |
|    |drop                                                                                  |
|    |                                                                                      |
|    |escaped                                                                               |
|    |enclosed                                                                              |
|    |enum                                                                                  |
|    |explain                                                                               |
|    |                                                                                      |
|    |exists                                                                                |
|    |fields                                                                                |
|    |first                                                                                 |
|    |float                                                                                 |
|    |                                                                                      |
|    |float4                                                                                |
|    |float8                                                                                |
|    |foreign                                                                               |
|    |from                                                                                  |
|    |                                                                                      |
|    |for                                                                                   |
|    |full                                                                                  |
|    |function                                                                              |
|    |grant                                                                                 |
|    |                                                                                      |
|    |group                                                                                 |
|    |having                                                                                |
|    |hour                                                                                  |
|    |hour_minute                                                                           |
|    |                                                                                      |
|    |hour_second                                                                           |
|    |ignore                                                                                |
|    |in                                                                                    |
|    |index                                                                                 |
|    |                                                                                      |
|    |infile                                                                                |
|    |insert                                                                                |
|    |int                                                                                   |
|    |integer                                                                               |
|    |                                                                                      |
|    |interval                                                                              |
|    |int1                                                                                  |
|    |int2                                                                                  |
|    |int3                                                                                  |
|    |                                                                                      |
|    |int4                                                                                  |
|    |int8                                                                                  |
|    |into                                                                                  |
|    |if                                                                                    |
|    |                                                                                      |
|    |is                                                                                    |
|    |join                                                                                  |
|    |key                                                                                   |
|    |keys                                                                                  |
|    |                                                                                      |
|    |last_insert_id                                                                        |
|    |leading                                                                               |
|    |left                                                                                  |
|    |like                                                                                  |
|    |                                                                                      |
|    |lines                                                                                 |
|    |limit                                                                                 |
|    |load                                                                                  |
|    |lock                                                                                  |
|    |                                                                                      |
|    |long                                                                                  |
|    |longblob                                                                              |
|    |longtext                                                                              |
|    |low_priority                                                                          |
|    |                                                                                      |
|    |match                                                                                 |
|    |mediumblob                                                                            |
|    |mediumtext                                                                            |
|    |mediumint                                                                             |
|    |                                                                                      |
|    |middleint                                                                             |
|    |minute                                                                                |
|    |minute_second                                                                         |
|    |month                                                                                 |
|    |                                                                                      |
|    |monthname                                                                             |
|    |natural                                                                               |
|    |numeric                                                                               |
|    |no                                                                                    |
|    |                                                                                      |
|    |not                                                                                   |
|    |null                                                                                  |
|    |on                                                                                    |
|    |option                                                                                |
|    |                                                                                      |
|    |optionally                                                                            |
|    |or                                                                                    |
|    |order                                                                                 |
|    |outer                                                                                 |
|    |                                                                                      |
|    |outfile                                                                               |
|    |partial                                                                               |
|    |password                                                                              |
|    |precision                                                                             |
|    |                                                                                      |
|    |primary                                                                               |
|    |procedure                                                                             |
|    |processlist                                                                           |
|    |privileges                                                                            |
|    |                                                                                      |
|    |quarter                                                                               |
|    |read                                                                                  |
|    |real                                                                                  |
|    |references                                                                            |
|    |                                                                                      |
|    |rename                                                                                |
|    |regexp                                                                                |
|    |reverse                                                                               |
|    |repeat                                                                                |
|    |                                                                                      |
|    |replace                                                                               |
|    |restrict                                                                              |
|    |returns                                                                               |
|    |rlike                                                                                 |
|    |                                                                                      |
|    |second                                                                                |
|    |select                                                                                |
|    |set                                                                                   |
|    |show                                                                                  |
|    |                                                                                      |
|    |smallint                                                                              |
|    |soname                                                                                |
|    |sql_big_tables                                                                        |
|    |sql_big_selects                                                                       |
|    |                                                                                      |
|    |sql_select_limit                                                                      |
|    |sql_low_priority_updates                                                              |
|    |sql_log_off                                                                           |
|    |sql_log_update                                                                        |
|    |                                                                                      |
|    |straight_join                                                                         |
|    |starting                                                                              |
|    |status                                                                                |
|    |string                                                                                |
|    |                                                                                      |
|    |table                                                                                 |
|    |tables                                                                                |
|    |terminated                                                                            |
|    |text                                                                                  |
|    |                                                                                      |
|    |time                                                                                  |
|    |timestamp                                                                             |
|    |tinyblob                                                                              |
|    |tinytext                                                                              |
|    |                                                                                      |
|    |tinyint                                                                               |
|    |trailing                                                                              |
|    |to                                                                                    |
|    |use                                                                                   |
|    |                                                                                      |
|    |using                                                                                 |
|    |unique                                                                                |
|    |unlock                                                                                |
|    |unsigned                                                                              |
|    |                                                                                      |
|    |update                                                                                |
|    |usage                                                                                 |
|    |values                                                                                |
|    |varchar                                                                               |
|    |                                                                                      |
|    |variables                                                                             |
|    |varying                                                                               |
|    |varbinary                                                                             |
|    |with                                                                                  |
|    |                                                                                      |
|    |write                                                                                 |
|    |where                                                                                 |
|    |year                                                                                  |
|    |year_month                                                                            |
|    |                                                                                      |
|    |zerofill                                                                              |
|    |                                                                                      |
|    |                                                                                      |
|    |                                                                                      |
|    |                                                                                      |
|    |Les valeurs suivantes issues de la table ci dessus) sont interdites par ANSI SQL, mais|
|    |autorisées par MySQL comme nom de table ou de colonne. Ceci, car ce sont des noms     |
|    |naturels, et de nombreuses personnes les utilisent déjà.                              |
|    |ACTION                                                                                |
|    |BIT                                                                                   |
|    |DATE                                                                                  |
|    |ENUM                                                                                  |
|    |NO                                                                                    |
|    |TEXT                                                                                  |
|    |TIME                                                                                  |
|    |TIMESTAMP                                                                             |
|    |8 Exemple MySQL                                                                       |
|    |Ce chapitre est une introduction à MySQL qui montre comment utiliser le client mysql  |
|    |pour créer et utiliser une base de données simple. mysql est un client (parfois       |
|    |appelée ``terminal'' ou aussi ``moniteur'') qui permet à un utilisateur de se         |
|    |connecter à un serveur MySQL, de lancer quelques requêtes, et de voir les résultats.  |
|    |mysql peut aussi être lancé en mode automatique, en lui précisant un fichier qui      |
|    |contient les commandes à exécuter. Cette présentation de mysql couvre les deux        |
|    |aspects.                                                                              |
|    |Pour avoir la liste des options disponibles sur mysql, il suffit d'utiliser l'option :|
|    |--help.                                                                               |
|    |                                                                                      |
|    |shell> mysql --help                                                                   |
|    |Ce chapitre supposera que mysql est installé sur votre machine, et qu'un serveur MySQL|
|    |est accessible. Si ce n'est pas le cas, contactez votre administrateur MySQL (Si vous |
|    |etes l'administrateur, vous aurez certainement besoin de consulter d'autres sections  |
|    |de ce manuel).                                                                        |
|    |Ce chapitre couvre la constitution et l'utilisation d'une base de données. Si vous    |
|    |êtes simplement interessé par la lecture de bases de données déjà existantes, vous    |
|    |pouvez éviter les premières sections qui montre la création d'une base de données et  |
|    |de tables.                                                                            |
|    |Etant donné que ce chapitre n'est qu'un exemple d'introduction, de nombreux détails   |
|    |sont laissés de coté. N'hésitez pas à vous reportez aux autres sections du manuel,    |
|    |pour toute information complémentaire.                                                |
|    |8.1 Connection et déconnection du serveur                                             |
|    |Pour se connecter au serveur MySQL, il vous faut un nom d'utilisateur, et, le plus    |
|    |probablement, un mot de passe. Si le serveur tourne sur une autre machine, il vous    |
|    |faudra aussi un nom d'hote. Contactez l'administrateur de la machine pour connaître   |
|    |les paramètres de connexion (i.e. le nom d'hote, le nom d'utilisateur, et le mot de   |
|    |passe). Une fois que vous connaîtrez tous ces paramètres, vous pourrez vous connecter |
|    |comme ceci :                                                                          |
|    |                                                                                      |
|    |shell> mysql -h host -u user -p                                                       |
|    |Enter password: ********                                                              |
|    |Les ******** représentent votre mot de passe : saisissez le lorsque mysql affiche the |
|    |Enter password (Entrez votre mot de passe): invite.                                   |
|    |Si tout a bien fonctionné, vous devriez voir s'afficher des informations              |
|    |d'introduction, suivies d'une invite de commande : mysql> prompt:                     |
|    |                                                                                      |
|    |shell> mysql -h host -u user -p                                                       |
|    |Enter password: ********                                                              |
|    |Welcome to the MySQL monitor.  Commands end with ; or \g.                             |
|    |Your MySQL connection id is 459 to server version: 3.22.20a-log                       |
|    |                                                                                      |
|    |Type 'help' for help.                                                                 |
|    |mysql>                                                                                |
|    |L'invite de commande vous indique que mysql est prêt à recevoir des commandes.        |
|    |Certaines installations de MySQL permettent l'accès anonyme au serveur. Si c'est le   |
|    |cas de votre machine, vous devriez pouvoir vous connecter sans fournir aucune         |
|    |information.                                                                          |
|    |                                                                                      |
|    |shell> mysql                                                                          |
|    |Après s'être correctement connecté, vous pouvez vous déconnecter à tout moment, en    |
|    |tapant QUIT à l'invite de mysql.                                                      |
|    |                                                                                      |
|    |mysql> QUIT                                                                           |
|    |Bye                                                                                   |
|    |Vous pouvez aussi vous déconnecter en tapant les touches contrôle-D.                  |
|    |Par la suite, nous supposerons que vous vous êtes correctement connecté au serveur.   |
|    |8.2 Soumettre une requête                                                             |
|    |Assurez vous que vous êtes correctement connecté. Dans le cas contraire, reportez vous|
|    |à la section précédente. Ce faisant, vous ne vous êtes en fait connecté à aucune base |
|    |de données, mais c'est bien comme ça. A ce stade ; il est important de savoir comment |
|    |envoyer une requête, avant de savoir créer une table, charger des données, et         |
|    |interroger la base. Cette section décrit les principes de base de saisie des          |
|    |commandes, en utilisant des commandes qui vous familiariseront avec le fonctionnement |
|    |de MySQL.                                                                             |
|    |Voici une commande simple qui demande au serveur la version et la date courante.      |
|    |Saisissez la comme ci-dessous, puis appuyez sur la touche entrée.                     |
|    |                                                                                      |
|    |mysql> SELECT VERSION(), CURRENT_DATE;                                                |
|    |+--------------+--------------+                                                       |
|    || version()    | CURRENT_DATE |                                                       |
|    |+--------------+--------------+                                                       |
|    || 3.22.20a-log | 1999-03-19   |                                                       |
|    |+--------------+--------------+                                                       |
|    |1 row in set (0.01 sec)                                                               |
|    |mysql>                                                                                |
|    |Cette première requête montre beaucoup de caractéristiques de mysql                   |
|    |Une commande consiste généralement d'une commande SQL, suivie d'un point-virgule (Il y|
|    |a quelques exceptions, ou les point-virgules ne sont pas nécessaires, comme la        |
|    |commande QUIT , vue précédement. Nous y reviendrons plus loin).                       |
|    |Quand une requête a été saisie, mysql l'envoie au serveur pour qu'il l'exécute, puis  |
|    |affiche le résultat, et repropose une nouvelle invite de commande : mysql>.           |
|    |Mysql> affiche la réponse du serveur sous forme de table (lignes et colonnes). La     |
|    |première ligne contient les titres des colonnes. Les lignes suivantes présentent les  |
|    |résultats de la requête. Généralement, les noms de colonnes sont les noms des colonnes|
|    |des tables utilisées. Si la valeur retournée est une expression plutôt qu'une table,  |
|    |(comme dans l'exemple ci-dessus), mysql crée une colonne avec comme titre l'expression|
|    |évaluée.                                                                              |
|    |mysql affiche le nombre de ligne retourné, et le temps de traitement de la requête, ce|
|    |qui donne une idée de la performance globale du serveur. Ces valeurs sont imprécises, |
|    |car elle représente le temps passé entre l'envoi de la commande et la réception de la |
|    |réponse, et ne montre pas quelle quantité de processeur a été utilisée. Cela ne permet|
|    |pas de connaître la charge du serveur, ou les retards du réseau.                      |
|    |Par un souci de concision, la ligne ``rows in set'' ne sera plus affichée dans les    |
|    |exemples ultérieurs.                                                                  |
|    |Les mots clés du langage peuvent être en majuscule ou minuscule, au choix. Les lignes |
|    |suivantes sont équivalentes :                                                         |
|    |                                                                                      |
|    |mysql> SELECT VERSION(), CURRENT_DATE;                                                |
|    |mysql> select version(), current_date;                                                |
|    |mysql> SeLeCt vErSiOn(), current_DATE;                                                |
|    |Voici une autre requête qui montre que mysql peut être utilisé comme une simple       |
|    |calculatrice.                                                                         |
|    |                                                                                      |
|    |mysql> SELECT SIN(PI()/4), (4+1)*5;                                                   |
|    |+-------------+---------+                                                             |
|    || SIN(PI()/4) | (4+1)*5 |                                                             |
|    |+-------------+---------+                                                             |
|    ||    0.707107 |      25 |                                                             |
|    |+-------------+---------+                                                             |
|    |Les commandes que nous venons de voir sont relativement courtes, et tiennent sur une  |
|    |seule ligne. Il est possible de saisir plusieurs commandes sur une seule ligne, il    |
|    |suffit de toujours les terminer par des points-virgules.                              |
|    |                                                                                      |
|    |mysql> SELECT VERSION(); SELECT NOW();                                                |
|    |+--------------+                                                                      |
|    || version()    |                                                                      |
|    |+--------------+                                                                      |
|    || 3.22.20a-log |                                                                      |
|    |+--------------+                                                                      |
|    |                                                                                      |
|    |+---------------------+                                                               |
|    || NOW()               |                                                               |
|    |+---------------------+                                                               |
|    || 1999-03-19 00:15:33 |                                                               |
|    |+---------------------+                                                               |
|    |Une commande n'est pas obligatoirement sur une seule ligne : les commandes les plus   |
|    |longues peuvent tenir sur plusieurs lignes. Ce n'est pas un problème, car mysql       |
|    |détermines la fin de la commandes gr?ce au point-virgule, et non pas en cherchant la  |
|    |fin de la ligne (en d'autres termes, mysql accepte n'importe quel format de colonne,  |
|    |mais ne les exécute que si il trouve un point-virgule à la fin de la commande).       |
|    |Voici une commande simple, et multi-lignes :                                          |
|    |                                                                                      |
|    |mysql> SELECT                                                                         |
|    |-> USER()                                                                             |
|    |-> ,                                                                                  |
|    |-> CURRENT_DATE;                                                                      |
|    |+--------------------+--------------+                                                 |
|    || USER()             | CURRENT_DATE |                                                 |
|    |+--------------------+--------------+                                                 |
|    || joesmith@localhost | 1999-03-18   |                                                 |
|    |+--------------------+--------------+                                                 |
|    |Dans cet exemples, vous avez pu remarquer que l'invite passe de mysql> à -> dès que la|
|    |commande devient multi-lignes. C'est par ce biais que mysql indique qu'il n'a pas     |
|    |trouvé une commande complète, et qu'il attend un complément d'information. En         |
|    |observant bien l'invite de commande, vous saurez toujours ce que mysql attend de vous.|
|    |                                                                                      |
|    |Pour annuler une commande qui est partiellement saisie, il suffit de taper '\c'       |
|    |(slash-c)                                                                             |
|    |                                                                                      |
|    |mysql> SELECT                                                                         |
|    |-> USER()                                                                             |
|    |-> \c                                                                                 |
|    |mysql>                                                                                |
|    |Ici, l'invite de commande reprend son aspect initial. Cela indique que mysql est prêt |
|    |pour une nouvelle commande.                                                           |
|    |La table suivante montre les différentes formes de l'invite de commande, et sa        |
|    |signification :                                                                       |
|    |Une commande peut s'étendre sur plusieurs lignes si, par accident, vous oubliez de    |
|    |terminer votre ligne par un point-virgule. Dans ce cas, mysql attend plus             |
|    |d'informations :                                                                      |
|    |                                                                                      |
|    |mysql> SELECT USER()                                                                  |
|    |->                                                                                    |
|    |Si cela vous arrive (vous pensez avoir entré une commande, mais la seule réponse est  |
|    |cette désespérante invite -> ) ; le plus souvent mysql attends le point-virgule. Si   |
|    |vous ne comprenez pas que mysql attend la suite de votre commande, vous risquez       |
|    |d'attendre un bon moment. Il suffit alors de compléter la commande avec un            |
|    |point-virgule, pour valider la commande.                                              |
|    |                                                                                      |
|    |mysql> SELECT USER()                                                                  |
|    |-> ;                                                                                  |
|    |+--------------------+                                                                |
|    || USER()             |                                                                |
|    |+--------------------+                                                                |
|    || joesmith@localhost |                                                                |
|    |+--------------------+                                                                |
|    |Les formes '> et "> d'invite de commande apparaissent lors de la saisie de chaînes.   |
|    |Avec MySQL, vous pouvez écrire des chaînes avec les guillemets simples et doubles :   |
|    |``''' ou ``"' ; 'comme par exemple 'bonjour' ou "au revoir". '> et "> signifie donc   |
|    |que vous avez commencé à saisir une chaîne de caractères, mais que vous n'avez pas    |
|    |encore fini. Si vous saisissez une chaîne de plusieurs lignes, c'est une indication   |
|    |judicieuse, mais est-ce souvent le cas? En général, ces deux invites de commande      |
|    |indiquent que vous avez oublié de refermer les guillemets :                           |
|    |                                                                                      |
|    |mysql> SELECT * FROM my_table WHERE nom = "Smith AND age < 30;                        |
|    |">                                                                                    |
|    |Si vous saisissez cette commande SELECT , puis tapez ENTREE, il ne va rien se passer. |
|    |Plutôt que de se demander " mais qu'est ce qui prend tant de temps ", il vaut mieux   |
|    |remarquer que l'invite a pris la forme particulière de "> . Cela signifie que mysql   |
|    |s'attend ce que vous complétiez votre chaîne et la commande. En effet, la chaîne      |
|    |"Smith n'a pas de deuxième guillemet.                                                 |
|    |A ce moment, que faire ? La chose la plus simplet d'annuler la commande. Cependant,   |
|    |vous ne pouvez pas taper \c , car mysql l'interprétera comme un caractère de chaîne. A|
|    |la place, il faut clore la chaîne, puis taper \c .                                    |
|    |                                                                                      |
|    |mysql> SELECT * FROM my_table WHERE nom = "Smith AND age < 30;                        |
|    |"> "\c                                                                                |
|    |mysql>                                                                                |
|    |L'invite de commande redevient mysql>, ce qui indique que mysql est prêt pour une     |
|    |nouvelle commande.                                                                    |
|    |Il est important que les invites de commande de la forme signifie '> et "> que vous   |
|    |n'avez pas terminé une chaîne, et que toutes les lignes suivantes seront ignorées par |
|    |l'analyseur de mysql – y compris la commande QUIT! Cela peut être déroutant, surtout  |
|    |si vous ne savez pas qu'il faut absolument fournir un guillemet de fin, même pour     |
|    |annuler la saisie                                                                     |
|    |8.3 Exemples de requêtes                                                              |
|    |Voici quelques exemples de requêtes classiques avec MySQL.                            |
|    |Certains des exemples utilisent la table 'shop' qui contient les prix de chaque       |
|    |article (numéro d'objet). Supposons que chaque objet a un prix unique, et que le      |
|    |couple (item, trader) et une clé prmiaire pour ces lignes.                            |
|    |Vous pouvez créer cet exemple avec la table suivante :                                |
|    |                                                                                      |
|    |CREATE TABLE shop (                                                                   |
|    |article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,                             |
|    |dealer  CHAR(20)                 DEFAULT ''     NOT NULL,                             |
|    |price   DOUBLE(16,2)             DEFAULT '0.00' NOT NULL,                             |
|    |PRIMARY KEY(article, dealer));                                                        |
|    |                                                                                      |
|    |INSERT INTO shop VALUES                                                               |
|    |(1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),(3,'C',1.69),                    |
|    |(3,'D',1.25),(4,'D',19.95);                                                           |
|    |Les données pour l'exemple sont :                                                     |
|    |                                                                                      |
|    |SELECT * FROM shop                                                                    |
|    |                                                                                      |
|    |+---------+--------+-------+                                                          |
|    || article | dealer | price |                                                          |
|    |+---------+--------+-------+                                                          |
|    ||    0001 | A      |  3.45 |                                                          |
|    ||    0001 | B      |  3.99 |                                                          |
|    ||    0002 | A      | 10.99 |                                                          |
|    ||    0003 | B      |  1.45 |                                                          |
|    ||    0003 | C      |  1.69 |                                                          |
|    ||    0003 | D      |  1.25 |                                                          |
|    ||    0004 | D      | 19.95 |                                                          |
|    |+---------+--------+-------+                                                          |
|    |8.3.1 Valeur maximale d'une colone                                                    |
|    |"Quel est le plus grand numéro d'objet?"                                              |
|    |                                                                                      |
|    |SELECT MAX(article) AS article FROM shop                                              |
|    |                                                                                      |
|    |+---------+                                                                           |
|    || article |                                                                           |
|    |+---------+                                                                           |
|    ||       4 |                                                                           |
|    |+---------+                                                                           |
|    |8.3.2 La ligne qui contient le maximum d'une colonne                                  |
|    |"Retrouver le prix, le vendeur et le numéro de l'objet le plus cher du magasin"       |
|    |En ANSI-SQL cela est très facilement fait avec un sous selection :                    |
|    |                                                                                      |
|    |SELECT article, dealer, price                                                         |
|    |FROM   shop                                                                           |
|    |WHERE  price=(SELECT MAX(price) FROM shop)                                            |
|    |Avec MySQL (et donc, sans les sous selections), il faut le faire en deux étapes :     |
|    |Retrouver la valeur maximale de la table, avec la commande SELECT.                    |
|    |Avec la valeur lue, créer la requêt suivante :                                        |
|    |                                                                                      |
|    |SELECT article, dealer, price                                                         |
|    |FROM   shop                                                                           |
|    |WHERE  price=19.95                                                                    |
|    |Une autre solution est de trier les objets par prix, et de lire la première ligne,    |
|    |avec la clause MySQL LIMIT:                                                           |
|    |                                                                                      |
|    |SELECT article, dealer, price                                                         |
|    |FROM   shop                                                                           |
|    |ORDER BY price DESC                                                                   |
|    |LIMIT 1                                                                               |
|    |Note: Avec cette méthode, on ne verra qu'ne seul objet, même si il y a plusieurs      |
|    |objets de meme prix.                                                                  |
|    |8.3.3 Maximum d'une colonne : par groupement                                          |
|    |"Quel est le prix maximal d'un article?"                                              |
|    |                                                                                      |
|    |SELECT article, MAX(price) AS price                                                   |
|    |FROM   shop                                                                           |
|    |GROUP BY article                                                                      |
|    |                                                                                      |
|    |+---------+-------+                                                                   |
|    || article | price |                                                                   |
|    |+---------+-------+                                                                   |
|    ||    0001 |  3.99 |                                                                   |
|    ||    0002 | 10.99 |                                                                   |
|    ||    0003 |  1.69 |                                                                   |
|    ||    0004 | 19.95 |                                                                   |
|    |+---------+-------+                                                                   |
|    |8.3.4 La ligne contenant le maximum d'une colonne d'un groupe                         |
|    |"Pour chaque article, trouver le vendeur le plus cher."                               |
|    |En ANSI SQL on pourrai le faire avec une sous selection, comme ceci :                 |
|    |                                                                                      |
|    |SELECT article, dealer, price                                                         |
|    |FROM   shop s1                                                                        |
|    |WHERE  price=(SELECT MAX(s2.price)                                                    |
|    |FROM shop s2                                                                          |
|    |WHERE s1.article = s2.article)                                                        |
|    |Avec MySQL il vaut mieux le faire en deux étapes :                                    |
|    |Retrouver la liste des (article,prix_maxima). 8.3.4 La ligne contenant le maximum     |
|    |d'une colonne d'un groupe.                                                            |
|    |pour chaque article trouvé, retrouver la ligne correspondante, pour lire le nom du    |
|    |vendeur. price.                                                                       |
|    |Cela peut se faire facilement avec une table temporaire:                              |
|    |                                                                                      |
|    |CREATE TEMPORARY TABLE tmp (                                                          |
|    |article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,                             |
|    |price   DOUBLE(16,2)             DEFAULT '0.00' NOT NULL);                            |
|    |                                                                                      |
|    |LOCK TABLES article read;                                                             |
|    |                                                                                      |
|    |INSERT INTO tmp SELECT article, MAX(price) FROM shop GROUP BY article;                |
|    |                                                                                      |
|    |SELECT article, dealer, price FROM shop, tmp                                          |
|    |WHERE shop.article=tmp.articel AND shop.price=tmp.price;                              |
|    |                                                                                      |
|    |UNLOCK TABLES;                                                                        |
|    |                                                                                      |
|    |DROP TABLE tmp;                                                                       |
|    |Si vous n'utislisez pas de table temporaire, il vous faut verrouiller la table.       |
|    |"Est ce qu'il est impossible de faire cela avec une seule requête?"                   |
|    |Oui, mais en utilisant une astuce qui s'appelle : "MAX-CONCAT trick":                 |
|    |                                                                                      |
|    |SELECT article,                                                                       |
|    |SUBSTRING( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 7) AS dealer,                     |
|    |0.00+LEFT(      MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 6) AS price                  |
|    |FROM   shop                                                                           |
|    |GROUP BY article;                                                                     |
|    |                                                                                      |
|    |+---------+--------+-------+                                                          |
|    || article | dealer | price |                                                          |
|    |+---------+--------+-------+                                                          |
|    ||    0001 | B      |  3.99 |                                                          |
|    ||    0002 | A      | 10.99 |                                                          |
|    ||    0003 | C      |  1.69 |                                                          |
|    ||    0004 | D      | 19.95 |                                                          |
|    |+---------+--------+-------+                                                          |
|    |Le dernier exemple peut être fait de manière plus efficace, en effectuant la scission |
|    |de la colonne au niveau du client; The last example can of course be made a bit more  |
|    |efficient by doing the                                                                |
|    |8.3.5 Utiliser des clés étrangères                                                    |
|    |Il n'y a pas besoin de clé étrangère pour joindre deux tables.                        |
|    |La seule chose que MySQL ne fait pas est de CHECK (vérifier) que les clés que vous    |
|    |utilisez existent vraiment dans la table que vous réféencez, et qu'il n'efface par de |
|    |lignes dnas une table avec une définition de clé étrangère. Si vous utilisez vos clés |
|    |de manière habituelle, cela fonctionnera parfaitement.                                |
|    |                                                                                      |
|    |CREATE TABLE persons (                                                                |
|    |id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,                                         |
|    |name CHAR(60) NOT NULL,                                                               |
|    |PRIMARY KEY (id)                                                                      |
|    |);                                                                                    |
|    |                                                                                      |
|    |CREATE TABLE shirts (                                                                 |
|    |id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,                                         |
|    |style ENUM('t-shirt', 'polo', 'dress') NOT NULL,                                      |
|    |color ENUM('red', 'blue', 'orange', 'white', 'black') NOT NULL,                       |
|    |owner SMALLINT UNSIGNED NOT NULL REFERENCES persons,                                  |
|    |PRIMARY KEY (id)                                                                      |
|    |);                                                                                    |
|    |                                                                                      |
|    |INSERT INTO persons VALUES (NULL, 'Antonio Paz');                                     |
|    |                                                                                      |
|    |INSERT INTO shirts VALUES                                                             |
|    |(NULL, 'polo', 'blue', LAST_INSERT_ID()),                                             |
|    |(NULL, 'dress', 'white', LAST_INSERT_ID()),                                           |
|    |(NULL, 't-shirt', 'blue', LAST_INSERT_ID());                                          |
|    |                                                                                      |
|    |INSERT INTO persons VALUES (NULL, 'Lilliana Angelovska');                             |
|    |                                                                                      |
|    |INSERT INTO shirts VALUES                                                             |
|    |(NULL, 'dress', 'orange', LAST_INSERT_ID()),                                          |
|    |(NULL, 'polo', 'red', LAST_INSERT_ID()),                                              |
|    |(NULL, 'dress', 'blue', LAST_INSERT_ID()),                                            |
|    |(NULL, 't-shirt', 'white', LAST_INSERT_ID());                                         |
|    |                                                                                      |
|    |SELECT * FROM persons;                                                                |
|    |+----+---------------------+                                                          |
|    || id | name                |                                                          |
|    |+----+---------------------+                                                          |
|    ||  1 | Antonio Paz         |                                                          |
|    ||  2 | Lilliana Angelovska |                                                          |
|    |+----+---------------------+                                                          |
|    |                                                                                      |
|    |SELECT * FROM shirts;                                                                 |
|    |+----+---------+--------+-------+                                                     |
|    || id | style   | color  | owner |                                                     |
|    |+----+---------+--------+-------+                                                     |
|    ||  1 | polo    | blue   |     1 |                                                     |
|    ||  2 | dress   | white  |     1 |                                                     |
|    ||  3 | t-shirt | blue   |     1 |                                                     |
|    ||  4 | dress   | orange |     2 |                                                     |
|    ||  5 | polo    | red    |     2 |                                                     |
|    ||  6 | dress   | blue   |     2 |                                                     |
|    ||  7 | t-shirt | white  |     2 |                                                     |
|    |+----+---------+--------+-------+                                                     |
|    |                                                                                      |
|    |SELECT s.* FROM persons p, shirts s                                                   |
|    |WHERE p.name LIKE 'Lilliana%'                                                         |
|    |AND s.owner = p.id                                                                    |
|    |AND s.color <> 'white';                                                               |
|    |                                                                                      |
|    |+----+-------+--------+-------+                                                       |
|    || id | style | color  | owner |                                                       |
|    |+----+-------+--------+-------+                                                       |
|    ||  4 | dress | orange |     2 |                                                       |
|    ||  5 | polo  | red    |     2 |                                                       |
|    ||  6 | dress | blue   |     2 |                                                       |
|    |+----+-------+--------+-------+                                                       |
|    |8.4 Créer et utiliser une base de données                                             |
|    |Si l'administrateur vous a créé une base de données pour vous, alors vous pouvez      |
|    |directement commencer à l'utiliser. Sinon, il vous faut la créer vous même :          |
|    |                                                                                      |
|    |mysql> CREATE DATABASE menagerie;                                                     |
|    |Sous Unix, les noms de base de données sont sensibles à la casse (contrairement aux   |
|    |mots clés SQL), donc il faudra faire référence à votre base de données sous le nom    |
|    |menagerie, et non pas Menagerie, MENAGERIE ou tout autre variante. Sous Windows, cette|
|    |restriction ne s'applique pas, même si vous devez faire référence à vos bases et      |
|    |tables de la même manière tout au long d'une même commande).                          |
|    |Créer une base de données ne la selectionne pas automatiquement. Il faut le faire     |
|    |explicitement. Pour faire de menagerie votre base courante, il faut utiliser la       |
|    |commande:                                                                             |
|    |                                                                                      |
|    |mysql> USE menagerie                                                                  |
|    |Database changed                                                                      |
|    |La base n'a besoin d'être crée qu'une seule fois, mais il faudra la sélectionner à    |
|    |chaque fois que vous commencerez une session mysql. Il suffira alors d'utiliser la    |
|    |même commande que ci-dessus. Alternativement, vous pouvez sélectionner une base dès la|
|    |connexion, en passant le nom de la base après tous les paramètres de connexion : .    |
|    |                                                                                      |
|    |shell> mysql -h host -u user -p menagerie                                             |
|    |Enter password: ********                                                              |
|    |Remarquez bien que menagerie n'est pas dans votre mot de passe. Si vous voulez        |
|    |transmettre votre mot de passe après l'option –p, vous devez le faire sans espace     |
|    |entre le mot de passe et l'option : (e.g., tel que -pmypassword, mais pas -p          |
|    |mypassword). Cependant, mettre votre mot de passe dans la ligne de connexion n'est pas|
|    |très recommandé, car cela vous rend vulnérable à tous les mouchards qui pourraient    |
|    |être sur votre machine.                                                               |
|    |8.4.1 Creéer une table                                                                |
|    |Créer une base de données est facile, mais, jusqu'à présent, c'est vide. La commande  |
|    |SHOW TABLES vous dira :                                                               |
|    |                                                                                      |
|    |mysql> SHOW TABLES;                                                                   |
|    |Empty set (0.00 sec)                                                                  |
|    |La partie la plus difficile est le choix de la structure de votre base de données, et |
|    |des tables dont vous aurez besoin, et quelles colonnes seront nécessaires.            |
|    |Vous pouvez envisager de créer une table qui créera un enregistrement pour chacun de  |
|    |vos animaux. Cette table portera le nom de animaux et devrait contenir au minimum le  |
|    |nom de l'animal. Etant donné que le nom seul n'est pas vraiment intéressant, il faudra|
|    |qu'il contienne aussi d'autres informations. Par exemple, si plusieurs personnes de   |
|    |votre famille ont des animaux domestiques, vous voudrez garder la liste de chaque     |
|    |maître. Vous voudrez peut être aussi conserver des informations basiques telles que le|
|    |genre ou la race.                                                                     |
|    |Et l'age ? Cela pourrait être intéressant à conserver, mais ce n'est pas une bonne    |
|    |chose à conserver dans une base de données. En effet, l'age change tous les jours, et |
|    |il faudrait changer constamment la base de données. Au contraire, il est bien mieux de|
|    |conserver la date de naissance. Alors, à chaque fois que vous aurez besoins de l'age, |
|    |il suffira de faire la différence entre la date du jour et la date de naissance. MySQL|
|    |disposent de puissantes fonctions de calculs sur les dates. Enregistrer la date de    |
|    |naissance plutôt quel l'age a d'autres atouts :                                       |
|    |Vous pourrez utiliser la base de données pour garder en mémoire les dates             |
|    |d'anniversaires de vos animaux (Si cela vous semble un peu idiot, remarquez bien que  |
|    |c'est exactement la même chose que de conserver la date d'anniversaire de vos clients,|
|    |et de leur envoyer cette carte d'anniversaire à la spontanéité toute informatique).   |
|    |Vous pourrez faire des calculs d'age en relation avec d'autres dates. Par exemple, si |
|    |vous enregistrer la date de mort, vous pourrez facilement calculer à quel age est mort|
|    |votre compagnon.                                                                      |
|    |Votre imagination fertile vous permettra sûrement d'imaginer une foule d'informations |
|    |utiles pour garnir la table animaux , mais les champs que nous venons d'identifier    |
|    |seront suffisant pour l'instant : le nom, le propriétaire, la race, le genre, la date |
|    |de naissance et celle de mort.                                                        |
|    |Utilisez maintenant la fonction de création de table pour créer la votre :            |
|    |                                                                                      |
|    |mysql> CREATE TABLE animaux (nom VARCHAR(20), proprietaire VARCHAR(20),               |
|    |-> espece VARCHAR(20), genre CHAR(1), naissance DATE, mort DATE);                     |
|    |VARCHAR est un bon choix pour le nom, le propriétaire et la race, car ces valeurs     |
|    |auront des longueurs variables. Les longueurs de ces colonnes n'ont pas besoin d'être |
|    |toutes identiques, ni de valoir 20. Vous pouvez choisir n'importe quelle longueur     |
|    |entre 1 et 255, du moment que cela vous semble approprié (si vous vous trompez , vous |
|    |pourrez toujours agrandir le champs avec la fonction MySQL : ALTER TABLE ).           |
|    |Le genre des animaux peu prendre de nombreuses formes, comme par exemple "m" et "f",  |
|    |ou peut être "male" et "femelle". Le plus simple sera d'utiliser les caractères "m" et|
|    |"f".                                                                                  |
|    |L'utilisation du type DATE pour représenter les dates de naissance naissance et de    |
|    |mort mort est un choix évident.                                                       |
|    |Maintenant que vous avez créer une table, , SHOW TABLES devrait être plus loquace :   |
|    |                                                                                      |
|    |mysql> SHOW TABLES;                                                                   |
|    |+---------------------+                                                               |
|    || Tables in menagerie |                                                               |
|    |+---------------------+                                                               |
|    || animaux                 |                                                           |
|    |+---------------------+                                                               |
|    |Pour vérifier que la table a été créée comme vous le désiriez, utilisez la commande   |
|    |DESCRIBE :                                                                            |
|    |                                                                                      |
|    |mysql> DESCRIBE animaux;                                                              |
|    |+----------------+-------------+------+-----+---------+-------+                       |
|    || Field          | Type        | Null | Key | Default | Extra |                       |
|    |+----------------+-------------+------+-----+---------+-------+                       |
|    || nom            | varchar(20) | YES  |     | NULL    |       |                       |
|    || proprietaire   | varchar(20) | YES  |     | NULL    |       |                       |
|    || espece         | varchar(20) | YES  |     | NULL    |       |                       |
|    || genre          | char(1)     | YES  |     | NULL    |       |                       |
|    || naissance      | date        | YES  |     | NULL    |       |                       |
|    || mort           | date        | YES  |     | NULL    |       |                       |
|    |+----------------+-------------+------+-----+---------+-------+                       |
|    |Vous pouvez utiliser DESCRIBE à tout moment, par exemple, si vous oubliez les noms de |
|    |colonnes ou leur type.                                                                |
|    |8.4.2 Charger des données dans une table                                              |
|    |Après avoir créé votre table, il faut la remplir. La fonction LOAD DATA et INSERT     |
|    |remplissent cette fonction.                                                           |
|    |Supposons que les informations sur vos animaux soient décrites comme dans le tableau  |
|    |ci-dessous : Remaquez bien que MySQL utilise un format de date de type AAAA-MM-JJ ;   |
|    |qui n'est pas le format standard.)                                                    |
|    |Etant donné que vous commencez avec une table vide, le meilleur moyen de remplir cette|
|    |table est de créer un fichier texte, chaque ligne contenant les informations d'un     |
|    |animal, puis de le charger directement dans la table avec une seule commande.         |
|    |Vous créez ainsi un fichier animaux.txt' contenant un enregistrement par ligne, avec  |
|    |des valeurs séparées par des tabulation, et dans le même ordre que l'ordre dans lequel|
|    |les colonnes ont été listées dans la commande CREATE TABLE. Pour les valeurs          |
|    |manquantes (comme par exemple, les genres inconnues, ou les dates de mort des animaux |
|    |vivants), vous pouvez utiliser la valeur NULL . Vous la représenterez dans le texte   |
|    |avec \N. Par exemple, l'enregistrement de l'oiseau Whistler ressemblera à ceci :      |
|    |Pour charger ce fichier `animaux.txt' dans la table animaux , utilisez la commande    |
|    |suivante :                                                                            |
|    |                                                                                      |
|    |mysql> LOAD DATA LOCAL INFILE "animaux.txt" INTO TABLE animaux;                       |
|    |Vous pourriez spécifier le type de chaque colonne et le marqueur de fin de ligne dans |
|    |la commande LOAD DATA si vous le désiriez, mais les valeurs par défaut (tabulations et|
|    |retour chariot) fonctionnent très bien ici.                                           |
|    |Pour n'ajouter qu'un seul enregistrement à la fois, la fonction INSERT est plus       |
|    |pratique : Dans sa forme la plus simple, vous fournissez les valeurs dans l'ordre des |
|    |colonnes. Par exemple, si Diane recoit un hamster du nom de Puffball, vous pourriez   |
|    |ajouter un nouvel enregistrement avec la commande suivante :                          |
|    |                                                                                      |
|    |mysql> INSERT INTO animaux                                                            |
|    |-> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);                       |
|    |Notez bien que les chaînes et les dates sont spécifiées avec des guillemets. De la    |
|    |même façon, vous pouvez insérer la valeur NULL directement pour représenter une valeur|
|    |manquante. N'utilisez pas \N comme pour LOAD DATA.                                    |
|    |A partir de cet exemple, vous voyez que la commande INSERT requiert nettement plus de |
|    |frappe au clavier que la fonction LOAD DATA                                           |
|    |8.4.3 Lire des informations dans une table                                            |
|    |La commande SELECT sert à lire des informations d'une table. La forme générale est la |
|    |suivante :                                                                            |
|    |                                                                                      |
|    |SELECT what_to_select                                                                 |
|    |FROM which_table                                                                      |
|    |WHERE conditions_to_satisfy                                                           |
|    |what_to_select indique ce que vous voulez affichier. Cela peut être une liste de      |
|    |champs, ou bien le joker * qui signifie ``toutes les colonnes'' which_table indique   |
|    |dans quelle table lire les informations. La clause WHERE est optionnelle. Si elle est |
|    |présente, conditions_to_satisfy spécifie les conditions qu'une ligne doit remplir pour|
|    |être retenue, et retournée.                                                           |
|    |8.4.3.1 Selection toutes les données                                                  |
|    |La forme la plus simple de SELECT permet d'obtenir la liste complète des ligne d'une  |
|    |table :                                                                               |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux;                                                         |
|    |+----------+---------------+---------+--------+----------------+------------+         |
|    || nom      | proprietaire  | espece  | genre  | naissance      | mort       |         |
|    |+----------+---------------+---------+--------+----------------+------------+         |
|    || Fluffy   | Harold        | chat    | f      | 1993-02-04     | NULL       |         |
|    || Claws    | Gwen          | chat    | m      | 1994-03-17     | NULL       |         |
|    || Buffy    | Harold        | chien   | f      | 1989-05-13     | NULL       |         |
|    || Fang     | Benny         | chien   | m      | 1990-08-27     | NULL       |         |
|    || Bowser   | Diane         | chien   | m      | 1998-08-31     | 1995-07-29 |         |
|    || Chirpy   | Gwen          | oiseau  | f      | 1998-09-11     | NULL       |         |
|    || Whistler | Gwen          | oiseau  | NULL   | 1997-12-09     | NULL       |         |
|    || Slim     | Benny         | serpent | m      | 1996-04-29     | NULL       |         |
|    || Puffball | Diane         | hamster | f      | 1999-03-30     | NULL       |         |
|    |+----------+---------------+---------+--------+----------------+------------+         |
|    |Cette forme de SELECT est utile pour passer en revue une table, comme par exemple, une|
|    |table que vous viendriez de charger. Dans cet exemple, la table ci-dessus montre qu'il|
|    |y a eu une erreur dans le fichier. Bowser semble être né après être mort ! En         |
|    |consultant son dossier, vous vous apercevez que sa date correcte de naissance est     |
|    |1989, et non pas 1998.                                                                |
|    |Il y a au moins deux façons de corriger cette erreur :                                |
|    |Editez le fichier `animaux.txt' pour corriger l'erreur, puis effacer la table ,et la  |
|    |recharger avec la DELETE et LOAD DATA:                                                |
|    |                                                                                      |
|    |mysql> DELETE FROM animaux;                                                           |
|    |mysql> LOAD DATA LOCAL INFILE "animaux.txt" INTO TABLE animaux;                       |
|    |Cependant, en faisant cela, il vous faudra aussi insérer de nouveau la fiche de       |
|    |Puffball.                                                                             |
|    |Ou bien, corriger seulement la fiche erronée avec une commande UPDATE :               |
|    |                                                                                      |
|    |mysql> UPDATE animaux SET naissance = "1989-08-31" WHERE nom = "Bowser";              |
|    |Dans cet exemple, on voit qu'il est facile de sélectionner toute la table. Mais       |
|    |généralement, ce n'est pas très pratique, surtout quand la table devient trop grande. |
|    |En général, il s'agit de réponse à une question plus spécifique, pour laquelle il va  |
|    |falloir ajouter des contraintes sur les informations à retourner. Voyons maintenant   |
|    |quelques exemples de requêtes.                                                        |
|    |8.4.3.2 Selectioner une partie des lignes                                             |
|    |Il est bien sûr possible de ne sélectionner quelques lignes dans une table. Mettons   |
|    |que vous souhaitiez vérifier que la nouvelle date de naissance de Bowser's a bien été |
|    |prise en compte. Il suffit de sélectionner l'enregistrement de Bowser comme ceci :    |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom = "Bowser";                                    |
|    |+--------+--------------+---------+--------+----------------+------------+            |
|    || nom    | proprietaire | espece  | genre  | naissance      | mort       |            |
|    |+--------+--------------+---------+--------+----------------+------------+            |
|    || Bowser | Diane        | chien   | m      | 1989-08-31     | 1995-07-29 |            |
|    |+--------+--------------+---------+--------+----------------+------------+            |
|    |Le résultat confirme bien que l'année de naissance est 1989, et non plus 1998.        |
|    |Les comparaisons de chaîne sont généralement insensible à la casse : on aurait plus   |
|    |préciser le nom "bowser", "BOWSER", etc. Le résultat aurait été le même.              |
|    |Vous pouvez faire des recherches sur d'autres colonnes que nom. Par exemple, si vous  |
|    |voulez savoir quels animaux sont nés 1998, faites un test sur la colonne naissance :  |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE naissance >= "1998-1-1";                           |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || nom      | proprietaire | espece  | genre  | naissance      | mort       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || Chirpy   | Gwen         | oiseau  | f      | 1998-09-11     | NULL       |          |
|    || Puffball | Diane        | hamster | f      | 1999-03-30     | NULL       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    |Vous pouvez aussi combiner les conditions : par exemple, pour rechercher les chiennes |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE espece = "chien" AND genre = "f";                  |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || nom      | proprietaire | espece  | genre  | naissance      | mort       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || Buffy    | Harold       | chien   | f      | 1989-05-13     | NULL       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    |La requête précédente utilisait l'opérateur logique AND (ET) Il y a aussi un opérateur|
|    |OR (OU) :                                                                             |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE espece = "serpent" OR espece = "oiseau";           |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || nom      | proprietaire | espece | genre  | naissance      | mort       |           |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || Chirpy   | Gwen         | oiseau  | f      | 1998-09-11     | NULL       |          |
|    || Whistler | Gwen         | oiseau  | NULL   | 1997-12-09     | NULL       |          |
|    || Slim     | Benny        | serpent | m      | 1996-04-29     | NULL       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    |AND et OR peut être utilisés dans la même requête. C'est alors une bonne idée         |
|    |d'utiliser des parenthèses pour préciser les regroupements :                          |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE (espece = "chat" AND genre = "m")                  |
|    |-> OR (espece = "chien" AND genre = "f");                                             |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || nom      | proprietaire | espece  | genre  | naissance      | mort       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    || Claws    | Gwen         | chat    | m      | 1994-03-17     | NULL       |          |
|    || Buffy    | Harold       | chien   | f      | 1989-05-13     | NULL       |          |
|    |+----------+--------------+---------+--------+----------------+------------+          |
|    |8.4.3.3 Selectionner une colonne spécifique                                           |
|    |Il se peut que vous n'ayez pas besoin de toutes les colonnes de votre table, mais     |
|    |juste de quelques colonnes. Il suffit alors de citer les colonnes qui vous            |
|    |intéressent. Par exemple, si vous ne voulez voir que les noms des animaux, avec leur  |
|    |date de naissance, il suffit de ne sélectionner que les colonnes nom et naissance:    |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance FROM animaux;                                            |
|    |+----------+------------+                                                             |
|    || nom      | naissance  |                                                             |
|    |+----------+------------+                                                             |
|    || Fluffy   | 1993-02-04 |                                                             |
|    || Claws    | 1994-03-17 |                                                             |
|    || Buffy    | 1989-05-13 |                                                             |
|    || Fang     | 1990-08-27 |                                                             |
|    || Bowser   | 1989-08-31 |                                                             |
|    || Chirpy   | 1998-09-11 |                                                             |
|    || Whistler | 1997-12-09 |                                                             |
|    || Slim     | 1996-04-29 |                                                             |
|    || Puffball | 1999-03-30 |                                                             |
|    |+----------+------------+                                                             |
|    |Pour lister les propriétaires d'animaux, utilisez la requête suivante :               |
|    |                                                                                      |
|    |mysql> SELECT proprietaire FROM animaux;                                              |
|    |+---------------+                                                                     |
|    || proprietaire  |                                                                     |
|    |+---------------+                                                                     |
|    || Harold        |                                                                     |
|    || Gwen          |                                                                     |
|    || Harold        |                                                                     |
|    || Benny         |                                                                     |
|    || Diane         |                                                                     |
|    || Gwen          |                                                                     |
|    || Gwen          |                                                                     |
|    || Benny         |                                                                     |
|    || Diane         |                                                                     |
|    |+---------------+                                                                     |
|    |Cependant, vous pouvez remarquer que cette requête simple affiche le champs           |
|    |proprietaire de chaque ligne, ce qui conduit à avoir des redondances (comme Gwen).    |
|    |Pour ne les voir apparaître qu'une seule fois, il faut utiliser le mot clé DISTINCT:  |
|    |                                                                                      |
|    |mysql> SELECT DISTINCT proprietaire FROM animaux;                                     |
|    |+---------------+                                                                     |
|    || proprietaire  |                                                                     |
|    |+---------------+                                                                     |
|    || Benny         |                                                                     |
|    || Diane         |                                                                     |
|    || Gwen          |                                                                     |
|    || Harold        |                                                                     |
|    |+---------------+                                                                     |
|    |Vous pouvez encore combiner une clause WHERE lors de la selection de lignes et de     |
|    |colonnes Par exemple, pour obtenir les dates de naissances des chiens et des chats,   |
|    |utilisez la requête suivante :                                                        |
|    |                                                                                      |
|    |mysql> SELECT nom, espece, naissance FROM animaux                                     |
|    |-> WHERE espece = "chien" OR espece = "chat";                                         |
|    |+--------+---------+------------+                                                     |
|    || nom    | espece  | naissance  |                                                     |
|    |+--------+---------+------------+                                                     |
|    || Fluffy | chat    | 1993-02-04 |                                                     |
|    || Claws  | chat    | 1994-03-17 |                                                     |
|    || Buffy  | chien   | 1989-05-13 |                                                     |
|    || Fang   | chien   | 1990-08-27 |                                                     |
|    || Bowser | chien   | 1989-08-31 |                                                     |
|    |+--------+---------+------------+                                                     |
|    |8.4.3.4 Trier les lignes                                                              |
|    |Vous avez pu remarquer que les lignes précédentes ont été affichées dans un ordre     |
|    |aléatoire. Comme il est plus facile d'analyser une requête dont les lignes ont été    |
|    |triées, il vaut mieux trier ces lignes avec la clause : ORDER BY :                    |
|    |Voici la liste des dates de naissances des animaux, classées par date :               |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance FROM animaux ORDER BY naissance;                         |
|    |+----------+------------+                                                             |
|    || nom      | naissance  |                                                             |
|    |+----------+------------+                                                             |
|    || Buffy    | 1989-05-13 |                                                             |
|    || Bowser   | 1989-08-31 |                                                             |
|    || Fang     | 1990-08-27 |                                                             |
|    || Fluffy   | 1993-02-04 |                                                             |
|    || Claws    | 1994-03-17 |                                                             |
|    || Slim     | 1996-04-29 |                                                             |
|    || Whistler | 1997-12-09 |                                                             |
|    || Chirpy   | 1998-09-11 |                                                             |
|    || Puffball | 1999-03-30 |                                                             |
|    |+----------+------------+                                                             |
|    |Pour inverser l'ordre de tri, ajoutez le mot clé DESC (descendant) après le nom de la |
|    |colonne que vous classez.                                                             |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance FROM animaux ORDER BY naissance DESC;                    |
|    |+----------+------------+                                                             |
|    || nom      | naissance  |                                                             |
|    |+----------+------------+                                                             |
|    || Puffball | 1999-03-30 |                                                             |
|    || Chirpy   | 1998-09-11 |                                                             |
|    || Whistler | 1997-12-09 |                                                             |
|    || Slim     | 1996-04-29 |                                                             |
|    || Claws    | 1994-03-17 |                                                             |
|    || Fluffy   | 1993-02-04 |                                                             |
|    || Fang     | 1990-08-27 |                                                             |
|    || Bowser   | 1989-08-31 |                                                             |
|    || Buffy    | 1989-05-13 |                                                             |
|    |+----------+------------+                                                             |
|    |Vous pouvez faire des classements avec plusieurs critères de tri. Par exemple, pour   |
|    |trier les animaux pas espèce, puis par naissance pour chaque type d'animaux, utilisez |
|    |la requête suivante :                                                                 |
|    |                                                                                      |
|    |mysql> SELECT nom, espece, naissance FROM animaux ORDER BY espece, naissance DESC;    |
|    |+----------+---------+------------+                                                   |
|    || nom      | espece  | naissance  |                                                   |
|    |+----------+---------+------------+                                                   |
|    || Chirpy   | oiseau  | 1998-09-11 |                                                   |
|    || Whistler | oiseau  | 1997-12-09 |                                                   |
|    || Claws    | chat    | 1994-03-17 |                                                   |
|    || Fluffy   | chat    | 1993-02-04 |                                                   |
|    || Fang     | chien   | 1990-08-27 |                                                   |
|    || Bowser   | chien   | 1989-08-31 |                                                   |
|    || Buffy    | chien   | 1989-05-13 |                                                   |
|    || Puffball | hamster | 1999-03-30 |                                                   |
|    || Slim     | serpent | 1996-04-29 |                                                   |
|    |+----------+---------+------------+                                                   |
|    |Notez bien que le mot clé DESC ne s'applique qu'à la colonne le précédent             |
|    |immédiatement (naissance); espece étant trié dans l'ordre ascendant.                  |
|    |8.4.3.5 Calculs sur les dates                                                         |
|    |MySQL possède de puissantes fonctions pour effectuer des calculs sur les dates, comme |
|    |par exemple, calculer un age, ou extraire des parties de date.                        |
|    |Pour déterminer l'age de chacun des animaux, il faut calculer la différence entre la  |
|    |naissance et la date courante. Puis, convertir ces deux dates en jours, et diviser le |
|    |tout par 365, pour avoir le nombre d'année.                                           |
|    |                                                                                      |
|    |mysql> SELECT nom, (TO_DAYS(NOW())-TO_DAYS(naissance))/365 FROM animaux;              |
|    |+----------+-----------------------------------------+                                |
|    || nom      | (TO_DAYS(NOW())-TO_DAYS(naissance))/365 |                                |
|    |+----------+-----------------------------------------+                                |
|    || Fluffy   |                                    6.15 |                                |
|    || Claws    |                                    5.04 |                                |
|    || Buffy    |                                    9.88 |                                |
|    || Fang     |                                    8.59 |                                |
|    || Bowser   |                                    9.58 |                                |
|    || Chirpy   |                                    0.55 |                                |
|    || Whistler |                                    1.30 |                                |
|    || Slim     |                                    2.92 |                                |
|    || Puffball |                                    0.00 |                                |
|    |+----------+-----------------------------------------+                                |
|    |Bien que cette requête fasse bien ce qu'on lui demande, il y a de la place pour       |
|    |quelques améliorations. En premier lieu, les résultats gagneraient à être classés. De |
|    |plus, le titre de la colonne n'est pas très explicite.                                |
|    |Le premier problème peut être résolu avec une clause ORDER BY nom qui va classer par  |
|    |ordre alphabétique. Pour régler le problème du titre, nous allons utiliser un alias.  |
|    |                                                                                      |
|    |mysql> SELECT nom, (TO_DAYS(NOW())-TO_DAYS(naissance))/365 AS age                     |
|    |-> FROM animaux ORDER BY nom;                                                         |
|    |+----------+------+                                                                   |
|    || nom      | age  |                                                                   |
|    |+----------+------+                                                                   |
|    || Bowser   | 9.58 |                                                                   |
|    || Buffy    | 9.88 |                                                                   |
|    || Chirpy   | 0.55 |                                                                   |
|    || Claws    | 5.04 |                                                                   |
|    || Fang     | 8.59 |                                                                   |
|    || Fluffy   | 6.15 |                                                                   |
|    || Puffball | 0.00 |                                                                   |
|    || Slim     | 2.92 |                                                                   |
|    || Whistler | 1.30 |                                                                   |
|    |+----------+------+                                                                   |
|    |Pour trier les résultats par age plutôt que par nom nom, il suffit de le mettre dans  |
|    |la clause ORDER BY :                                                                  |
|    |                                                                                      |
|    |mysql>  SELECT nom, (TO_DAYS(NOW())-TO_DAYS(naissance))/365 AS age                    |
|    |->  FROM animaux ORDER BY age;                                                        |
|    |+----------+------+                                                                   |
|    || nom     | age  |                                                                    |
|    |+----------+------+                                                                   |
|    || Puffball | 0.00 |                                                                   |
|    || Chirpy   | 0.55 |                                                                   |
|    || Whistler | 1.30 |                                                                   |
|    || Slim     | 2.92 |                                                                   |
|    || Claws    | 5.04 |                                                                   |
|    || Fluffy   | 6.15 |                                                                   |
|    || Fang     | 8.59 |                                                                   |
|    || Bowser   | 9.58 |                                                                   |
|    || Buffy    | 9.88 |                                                                   |
|    |+----------+------+                                                                   |
|    |Une requête similaire pourrait calculer l'age de mort des animaux morts. Pour cela,   |
|    |vous allez déterminer les animaux morts, en testant la colonne mort à NULL. Puis, pour|
|    |les valeurs non-NULL, calculez l'age avec les colonnes mort et naissance:             |
|    |                                                                                      |
|    |mysql>  SELECT nom, naissance, mort, (TO_DAYS(mort)-TO_DAYS(naissance))/365 AS age    |
|    |->  FROM animaux WHERE mort IS NOT NULL ORDER BY age;                                 |
|    |+--------+------------+------------+------+                                           |
|    || nom    | naissance  | mort       | age  |                                           |
|    |+--------+------------+------------+------+                                           |
|    || Bowser | 1989-08-31 | 1995-07-29 | 5.91 |                                           |
|    |+--------+------------+------------+------+                                           |
|    |La requête utilise mort IS NOT NULL plutôt que mort != NULL car NULL est une valeur   |
|    |spéciale. Cela est expliqué plus loin. Allez 8.4.3.6 Travailler avec la valeur NULL.  |
|    |Et comment rechercher les animaux dont l'anniversaire sera le mois prochain ? Pour ce |
|    |genre de calculs, year et day sont inutiles, il suffit d'extraire le mois de la       |
|    |colonne naissance . MySQL fournit plusieurs fonctions d'extraction comme par exemple  |
|    |YEAR(), MONTH() et DAY(). MONTH() est le plus approprié ici. Pour voir comment cela   |
|    |fonction, exécutez la commande suivante, qui naissance et MONTH(naissance):           |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance, MONTH(naissance) FROM animaux;                          |
|    |+----------+------------+------------------+                                          |
|    || nom      | naissance  | MONTH(naissance) |                                          |
|    |+----------+------------+------------------+                                          |
|    || Fluffy   | 1993-02-04 |                2 |                                          |
|    || Claws    | 1994-03-17 |                3 |                                          |
|    || Buffy    | 1989-05-13 |                5 |                                          |
|    || Fang     | 1990-08-27 |                8 |                                          |
|    || Bowser   | 1989-08-31 |                8 |                                          |
|    || Chirpy   | 1998-09-11 |                9 |                                          |
|    || Whistler | 1997-12-09 |               12 |                                          |
|    || Slim     | 1996-04-29 |                4 |                                          |
|    || Puffball | 1999-03-30 |                3 |                                          |
|    |+----------+------------+------------------+                                          |
|    |Trouver les animaux dont la date de naissance est le mois prochain est facile. En     |
|    |supposant que nous soyons au mois d'avril. Alors, le mois est le 4, et il suffit de   |
|    |rechercher les animaux nés au mois de May (5), comme ceci :                           |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance FROM animaux WHERE MONTH(naissance) = 5;                 |
|    |+-------+----------------+                                                            |
|    || nom   | naissance      |                                                            |
|    |+-------+----------------+                                                            |
|    || Buffy | 1989-05-13     |                                                            |
|    |+-------+----------------+                                                            |
|    |Il y a bien sur un cas particulier: décembre. Il ne suffit pas seulement d'ajouter 1 à|
|    |numéro du mois courant et de chercher les dates d'anniversaires correspondantes, car  |
|    |personne ne nait au mois 13. A la place, il faut chercher les animaux qui sont nés au |
|    |mois de janvier.                                                                      |
|    |Vous pourriez écrire une requête qui fonctionne, quelque soit le mois courant. De     |
|    |cette façon, vous n'aurez pas à utiliser un numéro particulier de mois dans la        |
|    |requête. DATE_ADD() vous permettra d'ajouter une durée de temps à une date. Si vous   |
|    |ajoutez un mois à la date de NOW(), puis vous en sortez le mois avec MONTH(), le      |
|    |résultat sera bien le mois suivant.                                                   |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance FROM animaux                                             |
|    |-> WHERE MONTH(naissance) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));                 |
|    |Une autre manière de faire serait d'ajouter 1 au mois courant, puis d'utiliser la     |
|    |(MOD) pour ``boucler'' à la fin de l'année, et faire correspondre janvier et décembre |
|    |:                                                                                     |
|    |                                                                                      |
|    |mysql> SELECT nom, naissance FROM animaux                                             |
|    |-> WHERE MONTH(naissance) = MOD(MONTH(NOW()),12) + 1;                                 |
|    |8.4.3.6 Travailler avec la valeur NULL                                                |
|    |La valeur NULL peut se comporter de manière surprenante si vous l'utilisez.           |
|    |Conceptuellement, NULL signifie ``valeur manquante '' ou `` valeur inconnue'' et il   |
|    |est traité de manière légèrement différente des autres valeurs. Pour tester une valeur|
|    |à NULL, vous ne pouvez pas utiliser les opérateurs de comparaison habituels, tels que |
|    |=, < or !=. Pour vous en convaincre, essayez la requête suivante :                    |
|    |                                                                                      |
|    |mysql> SELECT 1 = NULL, 1 != NULL, 1 < NULL, 1 > NULL;                                |
|    |+----------+-----------+----------+----------+                                        |
|    || 1 = NULL | 1 != NULL | 1 < NULL | 1 > NULL |                                        |
|    |+----------+-----------+----------+----------+                                        |
|    ||     NULL |      NULL |     NULL |     NULL |                                        |
|    |+----------+-----------+----------+----------+                                        |
|    |Clairement, vous n'obtiendrez aucun résultat significatif de ces comparaisons.        |
|    |Utilisez les opérateurs IS NULL et IS NOT NULL:                                       |
|    |                                                                                      |
|    |mysql> SELECT 1 IS NULL, 1 IS NOT NULL;                                               |
|    |+-----------+---------------+                                                         |
|    || 1 IS NULL | 1 IS NOT NULL |                                                         |
|    |+-----------+---------------+                                                         |
|    ||         0 |             1 |                                                         |
|    |+-----------+---------------+                                                         |
|    |Avec MySQL, 0 signifie faux et 1 signifie vrai.                                       |
|    |Cette gestion spéciale de NULL explique pourquoi, dans la section précédente, il était|
|    |nécessaire de savoir quels animaux étaient encore vivant, en utilisant mort IS NOT    |
|    |NULL à la place de mort != NULL.                                                      |
|    |8.4.3.7 Recherche de valeurs                                                          |
|    |MySQL propose les méthodes de recherche standard du SQL, mais aussi les recherches à  |
|    |base d'expression régulière, similaire à celle utilisées dans les utilitaires Unix,   |
|    |tels que vi, grep et sed.                                                             |
|    |Les méthodes de recherche SQL vous permettent d'utiliser le caractère ``_'' pour      |
|    |remplacer n'importe quel caractère unique, et ``%'' pour remplacer n'importe quel     |
|    |nombre de caractères (y compris le caractère 0). Les recherches SQL sont insensibles à|
|    |la casse. Reportez vous aux exemples ci-dessous. Remarquez bien que l'on n'utilise pas|
|    |= ou != mais plutôt LIKE ou NOT LIKE.                                                 |
|    |Recherche des noms commençant par ``b'':                                              |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom LIKE "b%";                                     |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || nom    | proprietaire  | espece | genre  | naissance      | mort       |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || Buffy  | Harold        | chien  | f      | 1989-05-13     | NULL       |            |
|    || Bowser | Diane         | chien  | m      | 1989-08-31     | 1995-07-29 |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    |Recherche des noms finissant par :``fy'':                                             |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom LIKE "%fy";                                    |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || nom    | proprietaire  | espece | genre  | naissance      | mort       |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || Fluffy | Harold        | chat   | f      | 1993-02-04     | NULL       |            |
|    || Buffy  | Harold        | chien  | f      | 1989-05-13     | NULL       |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    |Recherche des noms contenant ``w'':                                                   |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom LIKE "%w%";                                    |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || nom      | proprietaire  | espece | genre  | naissance      | mort       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || Claws    | Gwen          | chat   | m      | 1994-03-17     | NULL       |          |
|    || Bowser   | Diane         | chien  | m      | 1989-08-31     | 1995-07-29 |          |
|    || Whistler | Gwen          | oiseau | NULL   | 1997-12-09     | NULL       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    |Recherche des noms contenant exactement 5 caractères, utilisez le caractère ``_'' :   |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom LIKE "_____";                                  |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || nom      | proprietaire  | espece | genre  | naissance      | mort       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || Claws    | Gwen          | chat   | m      | 1994-03-17     | NULL       |          |
|    || Buffy    | Harold        | chien  | f      | 1989-05-13     | NULL       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    |L'autre type de recherche disponible avec MySQL est les expression régulières. Pour   |
|    |utiliser ce type de recherche, il faut ajouter les mots clé REGEXP et NOT REGEXP (ou  |
|    |RLIKE t NOT RLIKE, qui sont des synonymes).                                           |
|    |Les caractéristiques des expressions régulières sont :                                |
|    |``.'' remplace n'importe quel caractère qui n'apparaît qu'une fois.                   |
|    |Une classe de caractères ``[...]'' remplace n'importe quel caractère qui apparaît dans|
|    |les crochets. Par exemple, ``[abc]'' peut remplacer ``a'', ``b'' ou ``c''. Pour un    |
|    |intervalle de caractères, utilisez le tiret :. ``[a-z]'' remplace n'importe quelle    |
|    |lettre minuscule, et ``[0-9]'' remplace n'importe quel nombre.                        |
|    |``*'' remplace zéro ou plus occurrences du caractère le précédent immédiatement. Par  |
|    |exemple, ``x*'' remplace n'importe quelle nombre de ``x''. ``[0-9]*'' `'' remplace    |
|    |n'importe quelle nombre de chiffres, et ``.*'' remplace n'importe quelle nombre de    |
|    |caractères.                                                                           |
|    |Les expression régulières sont sensibles à la casse, mais vous pouvez utiliser une    |
|    |classe de caractères pour les rendre insensible à la casse. Par exemple, ``[aA]''     |
|    |remplace n'importe quel ``a'', minuscule ou majuscule, et ``[a-zA-Z]'' remplace       |
|    |n'importe quelle lettre, minuscule ou majuscule.                                      |
|    |La recherche est positive, si elle est vérifiée à n'importe quel endroit de la valeur |
|    |(en SQL, ce n'est vrai que sur la valeur entière).                                    |
|    |Pour contraindre une expression au début ou à la fin de la valeur, utilisez les       |
|    |caractères spéciaux ``^'' pour le début ou ``$'' pour la fin.                         |
|    |Pour illustrer le fonctionnement des expressions régulières, les requêtes précédentes |
|    |ont été réécrites en utilisant les expressions régulières.                            |
|    |Recherche des noms commençant par ``b'': on utilise ``^'' pour indiquer le début de la|
|    |valeur, et ``[bB]'' pour rechercher indifféremment, ``b'' minuscule ou majuscule.     |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom REGEXP "^[bB]";                                |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || nom    | proprietaire  | espece | genre  | naissance      | mort       |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || Buffy  | Harold        | chien  | f      | 1989-05-13     | NULL       |            |
|    || Bowser | Diane         | chien  | m      | 1989-08-31     | 1995-07-29 |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    |Recherche des noms finissant par :``fy'': on utilise ``$'' pour indiquer la fin de la |
|    |valeur                                                                                |
|    |                                                                                      |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || nom    | proprietaire  | espece | genre  | naissance      | mort       |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    || Fluffy | Harold        | chat   | f      | 1993-02-04     | NULL       |            |
|    || Buffy  | Harold        | chien  | f      | 1989-05-13     | NULL       |            |
|    |+--------+---------------+--------+--------+----------------+------------+            |
|    |Recherche des noms contenant ``w'':, on utilise ``[wW]'' pour rechercher les ``w',    |
|    |'minuscule ou majuscule :                                                             |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom REGEXP "[wW]";                                 |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || nom      | proprietaire  | espece | genre  | naissance      | mort       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || Claws    | Gwen          | chat   | m      | 1994-03-17     | NULL       |          |
|    || Bowser   | Diane         | chien  | m      | 1989-08-31     | 1995-07-29 |          |
|    || Whistler | Gwen          | oiseau | NULL   | 1997-12-09     | NULL       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    |Etant donné qu'une expression régulière est vrai si elle est vrai sur une partie d'une|
|    |valeur, il n'est pas besoin de caractères spéciaux.                                   |
|    |Recherche des noms contenant exactement 5 caractères, utilisez ``^'' et ``$'' pour    |
|    |indiquer le début et la fin de la chaîne, et 5 fois ``.'' pour les 5 caractères.      |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom REGEXP "^.....$";                              |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || nom      | proprietaire  | espece | genre  | naissance      | mort       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || Claws    | Gwen          | chat   | m      | 1994-03-17     | NULL       |          |
|    || Buffy    | Harold        | chien  | f      | 1989-05-13     | NULL       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    |Vous auriez pu aussi utiliser l'opérateur ``{n''} `` n-fois'':                        |
|    |                                                                                      |
|    |mysql> SELECT * FROM animaux WHERE nom REGEXP "^.{5}$";                               |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || nom      | proprietaire  | espece | genre  | naissance      | mort       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    || Claws    | Gwen          | chat   | m      | 1994-03-17     | NULL       |          |
|    || Buffy    | Harold        | chien  | f      | 1989-05-13     | NULL       |          |
|    |+----------+---------------+--------+--------+----------------+------------+          |
|    |8.4.3.8 Compter les lignes                                                            |
|    |Les bases de données sont souvent utilisées pour répondre aux questions du type :     |
|    |``combien de fois une information est-elle enregistrée dans une table?''. Par exemple,|
|    |vous pouvez souhaiter connaître le nombre d'animaux que vous avez, ou le nombre       |
|    |d'animaux de chaque propriétaire, ou encore toutes sortes de statistiques sur les     |
|    |animaux.                                                                              |
|    |Pour compter le nombre total d'animaux que vous avez, il suffit de compter le nombre  |
|    |de ligne dans la table animaux , puisqu'il y a un enregistrement par animal. La       |
|    |fonction COUNT() compte le nombre de ligne non-NULL. Votre requête ressemblera alors à|
|    |:                                                                                     |
|    |                                                                                      |
|    |mysql> SELECT COUNT(*) FROM animaux;                                                  |
|    |+----------+                                                                          |
|    || COUNT(*) |                                                                          |
|    |+----------+                                                                          |
|    ||        9 |                                                                          |
|    |+----------+                                                                          |
|    |Précédemment, vous avez recherché les noms des propriétaires d'animaux. Vous pouvez   |
|    |utiliser la fonction COUNT() pour connaître le nombre d'animaux que chaque            |
|    |propriétaire a :                                                                      |
|    |                                                                                      |
|    |mysql> SELECT proprietaire, COUNT(*) FROM animaux GROUP BY proprietaire;              |
|    |+---------------+----------+                                                          |
|    || proprietaire  | COUNT(*) |                                                          |
|    |+---------------+----------+                                                          |
|    || Benny         |        2 |                                                          |
|    || Diane         |        2 |                                                          |
|    || Gwen          |        3 |                                                          |
|    || Harold        |        2 |                                                          |
|    |+---------------+----------+                                                          |
|    |Remarques: l'utilisation de la clause GROUP BY qui rassemble les lignes par           |
|    |proprietaire. Sans cette clause, vous obtenez le message d'erreur suivant :           |
|    |                                                                                      |
|    |mysql> SELECT proprietaire, COUNT(proprietaire) FROM animaux;                         |
|    |ERROR 1140 at line 1: Mixing of GROUP columns (MIN(),MAX(),COUNT()...)                |
|    |with no GROUP columns is illegal if there is no GROUP BY clause                       |
|    |COUNT() et GROUP BY sont utiles pour caractériser vos informations dans de nombreuses |
|    |situations : Les exemples suivant effectuent des statistiques sur vos animaux :       |
|    |Nombre d'animaux par espèce                                                           |
|    |                                                                                      |
|    |mysql> SELECT espece, COUNT(*) FROM animaux GROUP BY espece;                          |
|    |+----------+----------+                                                               |
|    || espece   | COUNT(*) |                                                               |
|    |+----------+----------+                                                               |
|    || oiseau   |        2 |                                                               |
|    || chat     |        2 |                                                               |
|    || chien    |        3 |                                                               |
|    || hamster  |        1 |                                                               |
|    || serpent  |        1 |                                                               |
|    |+----------+----------+                                                               |
|    |Nombre d'animaux par genre:                                                           |
|    |                                                                                      |
|    |mysql> SELECT genre, COUNT(*) FROM animaux GROUP BY genre;                            |
|    |+-------+----------+                                                                  |
|    || genre | COUNT(*) |                                                                  |
|    |+-------+----------+                                                                  |
|    || NULL  |        1 |                                                                  |
|    || f     |        4 |                                                                  |
|    || m     |        4 |                                                                  |
|    |+-------+----------+                                                                  |
|    |(Dans cette réponse, NULL indique ``genre inconnu.'')                                 |
|    |Nombre d'animaux par espece et genre:                                                 |
|    |                                                                                      |
|    |mysql> SELECT espece, genre, COUNT(*) FROM animaux GROUP BY espece, genre;            |
|    |+---------+-------+----------+                                                        |
|    || espece  | genre | COUNT(*) |                                                        |
|    |+---------+-------+----------+                                                        |
|    || oiseau  | NULL  |        1 |                                                        |
|    || oiseau  | f     |        1 |                                                        |
|    || chat    | f     |        1 |                                                        |
|    || chat    | m     |        1 |                                                        |
|    || chien   | f     |        1 |                                                        |
|    || chien   | m     |        2 |                                                        |
|    || hamster | f     |        1 |                                                        |
|    || serpent | m     |        1 |                                                        |
|    |+---------+-------+----------+                                                        |
|    |Il n'y a pas besoin d'utiliser la table entière avec la fonction COUNT(). Par exemple,|
|    |la requête précédente effectuée sur la population de chien et de chat devient:        |
|    |                                                                                      |
|    |mysql> SELECT espece, genre, COUNT(*) FROM animaux                                    |
|    |-> WHERE espece = "chien" OR espece = "chat"                                          |
|    |-> GROUP BY espece, genre;                                                            |
|    |+---------+-------+----------+                                                        |
|    || espece  | genre | COUNT(*) |                                                        |
|    |+---------+-------+----------+                                                        |
|    || chat    | f     |        1 |                                                        |
|    || chat    | m     |        1 |                                                        |
|    || chien   | f     |        1 |                                                        |
|    || chien   | m     |        2 |                                                        |
|    |+---------+-------+----------+                                                        |
|    |Ou, pour avoir le nombre d'animaux par genre, et pour les espèces connues :           |
|    |                                                                                      |
|    |mysql> SELECT espece, genre, COUNT(*) FROM animaux                                    |
|    |-> WHERE genre IS NOT NULL                                                            |
|    |-> GROUP BY espece, genre;                                                            |
|    |+---------+-------+----------+                                                        |
|    || espece  | genre | COUNT(*) |                                                        |
|    |+---------+-------+----------+                                                        |
|    || oiseau  | f     |        1 |                                                        |
|    || chat    | f     |        1 |                                                        |
|    || chat    | m     |        1 |                                                        |
|    || chien   | f     |        1 |                                                        |
|    || chien   | m     |        2 |                                                        |
|    || hamster | f     |        1 |                                                        |
|    || serpent | m     |        1 |                                                        |
|    |+---------+-------+----------+                                                        |
|    |8.4.4 Utiliser plus d'une table                                                       |
|    |La table animaux contient la liste des animaux que vous avez. Vous pourriez vouloir   |
|    |enregistrer d'autres informations à leur sujet, telles que des évènements de leur vie,|
|    |comme les visites chez le vétérinaire, ou les dates des portées de petits : vous avez |
|    |besoin d'une autre table. A quoi va t elle ressembler ?                               |
|    |Elle va devoir contenir les noms des animaux, pour savoir à qui c'est arrivé.         |
|    |Il faut une date pour l'événement.                                                    |
|    |Il faut un champs de description des événements                                       |
|    |Il faut aussi un champs de catégorie d'événement.                                     |
|    |Avec ces indications, la requête de CREATE TABLE va ressembler à ceci :               |
|    |                                                                                      |
|    |mysql> CREATE TABLE event (nom VARCHAR(20), date DATE,                                |
|    |-> type VARCHAR(15), remark VARCHAR(255));                                            |
|    |Comme pour la table animaux table, il est plus facile de charger les premières valeurs|
|    |à partir d'un fichier, dont les champs sont délimités avec des tabulations :          |
|    |Chargez les informations comme ceci :                                                 |
|    |                                                                                      |
|    |mysql> LOAD DATA LOCAL INFILE "event.txt" INTO TABLE event;                           |
|    |Etant donné ce que vous avez appris avec les requêtes sur la table animaux table, vous|
|    |devriez être capable d'exécuter des requêtes sur la table event; les principes sont   |
|    |les mêmes. Mais la table event pourrait se révéler insuffisante pour répondre à vos   |
|    |questions.                                                                            |
|    |Supposons que vous voulez avoir l'age des animaux lorsqu'ils ont eu leur portée. La   |
|    |table event indique quand ils ont eu leur portée, mais pour calculer l'age de la mère,|
|    |il faut aussi sa date de naissance. Etant donné que cette date est stockée dans la    |
|    |table animaux, vous avez besoin des deux tables dans la même requête :                |
|    |                                                                                      |
|    |mysql> SELECT animaux.nom, (TO_DAYS(date) - TO_DAYS(naissance))/365 AS age, remarque  |
|    |-> FROM animaux, event                                                                |
|    |-> WHERE animaux.nom = event.nom AND type = "portée";                                 |
|    |+--------+------+-------------------------------+                                     |
|    || nom    | age  | remarque                      |                                     |
|    |+--------+------+-------------------------------+                                     |
|    || Fluffy | 2.27 | 4 chatons, 3 femelles, 1 male |                                     |
|    || Buffy  | 4.12 | 5 chiots, 2 femelles, 3 male  |                                     |
|    || Buffy  | 5.10 | 3 chiots, 3 femelles          |                                     |
|    |+--------+------+-------------------------------+                                     |
|    |Il faut remarquer plusieurs choses à propos de cette requête :                        |
|    |La clause FROM est une liste contenant les noms des deux tables, car la requête clause|
|    |va chercher des informations dans ces deux tables.                                    |
|    |Lorsque vous combinez des informations entre plusieurs tables, il faut spécifier      |
|    |comment les lignes vont correspondre. Ici, la correspondance est simple, et basée sur |
|    |la colonne nom. La requête utilise une clause WHERE pour rechercher et assortir les   |
|    |valeurs des deux tables, avec la colonne nom.                                         |
|    |Etant donné que les deux tables ont une colonne nom il faut préciser la table         |
|    |d'appartenance de ces colonnes à chaque référence. C'est facilement faisable en       |
|    |ajoutant simplement le nom de la table devant le nom de la colonne.                   |
|    |Les regroupements sont aussi possibles sur une même table. Cela revient à comparer des|
|    |valeurs d'une table avec d'autres valeurs de la même table. Par exemple, pour marier  |
|    |vos animaux entre eux, vous pouvez faire un regroupement de la table animaux avec     |
|    |elle-même pour rechercher les males et femelles de la même espèce :                   |
|    |                                                                                      |
|    |mysql> SELECT p1.nom, p1.genre, p2.nom, p2.genre, p1.espece                           |
|    |-> FROM animaux AS p1, animaux AS p2                                                  |
|    |-> WHERE p1.espece = p2.espece AND p1.genre = "f" AND p2.genre = "m";                 |
|    |+--------+-------+--------+-------+---------+                                         |
|    || nom    | genre | nom    | genre | espece  |                                         |
|    |+--------+-------+--------+-------+---------+                                         |
|    || Fluffy | f     | Claws  | m     | chat    |                                         |
|    || Buffy  | f     | Fang   | m     | chien   |                                         |
|    || Buffy  | f     | Bowser | m     | chien   |                                         |
|    |+--------+-------+--------+-------+---------+                                         |
|    |Dans cette requête, plusieurs alias sont définis pour pouvoir faire référence à chaque|
|    |instance de la table, et à la bonne colonne.                                          |
|    |8.5 Informations sur les bases de données et tables                                   |
|    |Que se passe t il si vous oubliez le nom d'une base de données, d'une table ou la     |
|    |structure d'une table donnée ? MySQL résoud ce problème avec plusieurs commandes qui  |
|    |fournissent des informations sur les bases et les tables.                             |
|    |Vous avez déjà rencontré SHOW DATABASES, qui liste les bases gérés par le serveur.    |
|    |Pour connaître la base de données courante, utilisez DATABASE():                      |
|    |                                                                                      |
|    |mysql> SELECT DATABASE();                                                             |
|    |+------------+                                                                        |
|    || DATABASE() |                                                                        |
|    |+------------+                                                                        |
|    || menagerie  |                                                                        |
|    |+------------+                                                                        |
|    |Si vous n'avez pas de base sélectionnée, le résultat est vide.                        |
|    |Pour connaître les tables de la base de données courante, (par exemple, si vous n'êtes|
|    |pas sur du nom d'une table), utilisez la commande suivante :                          |
|    |                                                                                      |
|    |mysql> SHOW TABLES;                                                                   |
|    |+---------------------+                                                               |
|    || Tables in menagerie |                                                               |
|    |+---------------------+                                                               |
|    || event               |                                                               |
|    || animaux             |                                                               |
|    |+---------------------+                                                               |
|    |Pour connaître les colonnes d'une table, (par exemple, si vous n'êtes pas sur du nom  |
|    |d'une colonne), utilisez la commande suivante :                                       |
|    |                                                                                      |
|    |mysql> DESCRIBE animaux;                                                              |
|    |+----------------+-------------+------+-----+---------+-------+                       |
|    || Field          | Type        | Null | Key | Default | Extra |                       |
|    |+----------------+-------------+------+-----+---------+-------+                       |
|    || nom            | varchar(20) | YES  |     | NULL    |       |                       |
|    || proprietaire   | varchar(20) | YES  |     | NULL    |       |                       |
|    || espece         | varchar(20) | YES  |     | NULL    |       |                       |
|    || genre          | char(1)     | YES  |     | NULL    |       |                       |
|    || naissance      | date        | YES  |     | NULL    |       |                       |
|    || mort           | date        | YES  |     | NULL    |       |                       |
|    |+----------------+-------------+------+-----+---------+-------+                       |
|    |Field donne le nom de la colonne, Type est le type de données, Null indique si la     |
|    |colonne accepte la valeur NULL ou pas, Key indique que la colonne est manual_tocée, et|
|    |Default indique la valeur par défaut de la colonne.                                   |
|    |Si vous avez des manual_toc sur une table, SHOW manual_toc FROM tbl_nom fournit la    |
|    |liste des informations les concernant.                                                |
|    |8.6 Utiliser mysql en mode batch                                                      |
|    |Dans les sections précédentes, vous avez utilisé mysql de manière interactive pour    |
|    |entrer des requête et voir les résultats.Vous pouvez aussi utiliser mysql en mode     |
|    |batch. Pour cela, il faut mettre les commandes que vous souhaitez exécuter dans un    |
|    |fichier, puis indiquez à mysql qu'il faut l'utiliser comme fichier d'entrée.          |
|    |                                                                                      |
|    |shell> mysql < batch-file                                                             |
|    |Si vous devez préciser des paramètres de connexions sur la ligne de commande, elle    |
|    |peut ressembler à ceci :                                                              |
|    |                                                                                      |
|    |shell> mysql -h host -u user -p < batch-file                                          |
|    |Enter password: ********                                                              |
|    |Quand vous utilisez mysql de cette façon, vous créez un fichier de script, puis       |
|    |exécutez ce script.                                                                   |
|    |Pourquoi utiliser un script ? Voici quelques réponses :                               |
|    |Si vous exécutez une requête de manière régulière (par exemple, tous les jours, toutes|
|    |les semaines), utiliser un script vous évitera de tout retaper à la main à chaque     |
|    |fois.                                                                                 |
|    |Vous pouvez générer de nouvelles requêtes à partir d'autre requête déjà existantes, en|
|    |utilisant le copier/coller.                                                           |
|    |Le mode batch peut être pratique lorsque vous développez des requêtes de plusieurs    |
|    |lignes, ou des séquences de requêtes. A chaque erreur, vous n'avez pas tout à retaper,|
|    |mais juste la commande erronée. Il suffit pour ca d'éditer le script, et de le faire  |
|    |ré exécuter.                                                                          |
|    |Si une requête génère beaucoup d'informations, vous pouvez les voir avec un outil     |
|    |adapté, plutôt que de les regarder simplement défiler sur l'écran.                    |
|    |                                                                                      |
|    |shell> mysql < batch-file | more                                                      |
|    |Vous pouvez enregistrer les résultats dans un fichier pour les retraiter ailleurs     |
|    |                                                                                      |
|    |shell> mysql < batch-file > mysql.out                                                 |
|    |Vous pouvez distribuer le script à d'autres personnes, pour qu'ils puissent exécuter  |
|    |ces commandes aussi.                                                                  |
|    |Certaines utilisations n'autorisent pas l'utilisation interactif, comme par exemple,  |
|    |la commande cron. Dans ce cas, il faut utiliser le mode batch.                        |
|    |Le format de réponse en mode batch est plus concis qu'en mode intéractif. Par exemple |
|    |SELECT DISTINCT espece FROM animaux ressemble à ceci ,en mode intéractif :            |
|    |                                                                                      |
|    |+---------+                                                                           |
|    || espece  |                                                                           |
|    |+---------+                                                                           |
|    || oiseau  |                                                                           |
|    || chat    |                                                                           |
|    || chien   |                                                                           |
|    || hamster |                                                                           |
|    || serpent |                                                                           |
|    |+---------+                                                                           |
|    |Mais en mode batch, il ressemble à ceci :                                             |
|    |                                                                                      |
|    |espece                                                                                |
|    |oiseau                                                                                |
|    |chat                                                                                  |
|    |chien                                                                                 |
|    |hamster                                                                               |
|    |serpent                                                                               |
|    |Pour obtenir un format de réponse " intéractif " à partir du mode batch, utilisez     |
|    |l'option mysql -t. Pour avoir aussi les commandes exécutées utilisez l'option mysql   |
|    |-vvv.                                                                                 |
|    |8.7 Requêtes pour le projet "jumeaux"                                                 |
|    |Chez Analytikerna and Lentus (NDT : société de l'auteur), nous avons pris en charge   |
|    |l'étude du système et l'architecture des données pour un grand projet de recherche. Ce|
|    |projet est une collaboration entre l' Institut de médecine environnementale à         |
|    |Karolinska Institutet, Stockholm et la Section Recherche Clinique sur l'age et la     |
|    |psychologie, de l'université de Californie du Sud.                                    |
|    |Ce projet avait une grosse partie d'enquête, où tous les jumeaux suédois de plus de 65|
|    |ans étaient interviewés par téléphone. Les jumeaux qui remplissaient certains critères|
|    |étaient admis dans la phase suivante de l'enquête. Dans cette deuxième phase, les     |
|    |jumeaux qui souhaitaient participer, recevaient la visite d'un docteur et d'une       |
|    |infirmière. Une partie des questionnaires étaient des examens physiques et            |
|    |neuropsychologiques, des tests de laboratoire, des scanners du cerveau, des analyses  |
|    |psychologique, et des études généalogiques. De plus, des informations étaient         |
|    |rassemblées sur les risques médicaux et environnementaux.                             |
|    |Pour plus d'information a propos de ce projet, suivez le lien suivant (en anglais) :  |
|    |                                                                                      |
|    |http://www.imm.ki.se/TWIN/TWINUKW.HTM                                                 |
|    |La deuxième partie du projet est accessible par une interface web, écrite en Perl et  |
|    |MySQL.                                                                                |
|    |Chaque nuit, les informations des réunions étaient inséréees dans les base MySQL.     |
|    |8.7.1 Trouver tous les jumeaux non distribués                                         |
|    |8.7.1 Trouver tous les jumeaux non distribués                                         |
|    |Les requêtes suivantes sont utilisées pour sélectionner les couples de jumeaux qui    |
|    |accèderont à la deuxième phase :                                                      |
|    |                                                                                      |
|    |select                                                                                |
|    |concat(p1.id, p1.tvab) + 0 as tvid,                                                   |
|    |concat(p1.christian_nom, " ", p1.surnom) as Nom,                                      |
|    |p1.postal_code as Code,                                                               |
|    |p1.city as City,                                                                      |
|    |pg.abrev as Area,                                                                     |
|    |if(td.participation = "Aborted", "A", " ") as A,                                      |
|    |p1.dead as dead1,                                                                     |
|    |l.event as event1,                                                                    |
|    |td.suspect as tsuspect1,                                                              |
|    |id.suspect as isuspect1,                                                              |
|    |td.severe as tsevere1,                                                                |
|    |id.severe as isevere1,                                                                |
|    |p2.dead as dead2,                                                                     |
|    |l2.event as event2,                                                                   |
|    |h2.nurse as nurse2,                                                                   |
|    |h2.doctor as doctor2,                                                                 |
|    |td2.suspect as tsuspect2,                                                             |
|    |id2.suspect as isuspect2,                                                             |
|    |td2.severe as tsevere2,                                                               |
|    |id2.severe as isevere2,                                                               |
|    |l.finish_date                                                                         |
|    |from                                                                                  |
|    |twin_project as tp                                                                    |
|    |/* For Twin 1 */                                                                      |
|    |left join twin_data as td on tp.id = td.id and tp.tvab = td.tvab                      |
|    |left join informant_data as id on tp.id = id.id and tp.tvab = id.tvab                 |
|    |left join harmony as h on tp.id = h.id and tp.tvab = h.tvab                           |
|    |left join lentus as l on tp.id = l.id and tp.tvab = l.tvab                            |
|    |/* For Twin 2 */                                                                      |
|    |left join twin_data as td2 on p2.id = td2.id and p2.tvab = td2.tvab                   |
|    |left join informant_data as id2 on p2.id = id2.id and p2.tvab = id2.tvab              |
|    |left join harmony as h2 on p2.id = h2.id and p2.tvab = h2.tvab                        |
|    |left join lentus as l2 on p2.id = l2.id and p2.tvab = l2.tvab,                        |
|    |person_data as p1,                                                                    |
|    |person_data as p2,                                                                    |
|    |postal_groups as pg                                                                   |
|    |where                                                                                 |
|    |/* p1 gets main twin and p2 gets his/her twin. */                                     |
|    |/* ptvab is a field inverted from tvab */                                             |
|    |p1.id = tp.id and p1.tvab = tp.tvab and                                               |
|    |p2.id = p1.id and p2.ptvab = p1.tvab and                                              |
|    |/* Just the sceening survey */                                                        |
|    |tp.survey_no = 5 and                                                                  |
|    |/* Skip if partner died before 65 but allow emigration (dead=9) */                    |
|    |(p2.dead = 0 or p2.dead = 9 or                                                        |
|    |(p2.dead = 1 and                                                                      |
|    |(p2.mort_date = 0 or                                                                  |
|    |(((to_days(p2.mort_date) - to_days(p2.naissanceday)) / 365)                           |
|    |>= 65))))                                                                             |
|    |and                                                                                   |
|    |(                                                                                     |
|    |/* Twin is suspect */                                                                 |
|    |(td.future_contact = 'Yes' and td.suspect = 2) or                                     |
|    |/* Twin is suspect - Informant is Blessed */                                          |
|    |(td.future_contact = 'Yes' and td.suspect = 1 and id.suspect = 1) or                  |
|    |/* No twin - Informant is Blessed */                                                  |
|    |(ISNULL(td.suspect) and id.suspect = 1 and id.future_contact = 'Yes') or              |
|    |/* Twin broken off - Informant is Blessed */                                          |
|    |(td.participation = 'Aborted'                                                         |
|    |and id.suspect = 1 and id.future_contact = 'Yes') or                                  |
|    |/* Twin broken off - No inform - Have partner */                                      |
|    |(td.participation = 'Aborted' and ISNULL(id.suspect) and p2.dead = 0))                |
|    |and                                                                                   |
|    |l.event = 'Finished'                                                                  |
|    |/* Get at area code */                                                                |
|    |and substring(p1.postal_code, 1, 2) = pg.code                                         |
|    |/* Not already distributed */                                                         |
|    |and (h.nurse is NULL or h.nurse=00 or h.doctor=00)                                    |
|    |/* Has not refused or been aborted */                                                 |
|    |and not (h.status = 'Refused' or h.status = 'Aborted'                                 |
|    |or h.status = 'Died' or h.status = 'Other')                                           |
|    |order by                                                                              |
|    |tvid;                                                                                 |
|    |Quelques explications s'imposent :                                                    |
|    |•  concat(p1.id, p1.tvab) + 0 as tvid                                                 |
|    |On veut trier les valeurs avec la concaténation de id et tvab dans un ordre numérique.|
|    |Ajouter 0 au nombre force MySQL à traiter le résultat comme un nombre                 |
|    |column id                                                                             |
|    |Ceci identifiera un couple de jumeaux. C'est une clé commune à toutes les tables.     |
|    |column tvab                                                                           |
|    |Cette colonne identifie un des jumeaux dans un couple. Il prend la valeur de 1 ou 2.  |
|    |column ptvab                                                                          |
|    |C'est le complémentaire de la colonne précédente. Quand tvab vaut 1 celle-ci vaut 2,  |
|    |et vice versa. Elle sert à éviter des saisie, et permet à MySQL d'optimiser la        |
|    |requête.                                                                              |
|    |Cette requête démontre, entre autres choses, comment faire des recherches dans une    |
|    |table à partir de la même table, gr?ce à un regroupement ( (p1 et p2). Dans l'exemple |
|    |ci-dessus, on s'en sert pour vérifier si le deuxième jumeau n'est pas mort avant l'age|
|    |de 65 ans. Dans ce cas, la ligne n'est pas renvoyée.                                  |
|    |Toutes les informations ci-dessus existent dans les tables sur les jumeaux. Il y a    |
|    |toujours une clé sur id,tvab (toutes tables) et id,ptvab (person_data) pour rendre les|
|    |requêtes plus rapides.                                                                |
|    |Sur notre serveur de production (une station Sun UltraSPARC 200MHz), cettre requête   |
|    |retourne entre 150 et 200 lignes, et prend moins d'une seconde.                       |
|    |Le nombre courant de ligne dans les tables sont les suivants :                        |
|    |8.7.2 Afficher une table par pair de jumeau                                           |
|    |Chaque interview est conclu par un status appelé event. La requête ci-dessous est     |
|    |utilisée pour créer une table avec toutes les paires de jumeaux. Elle indique aussi le|
|    |nombre de couples qui ont terminé les entretiens, les couples où un seul jumeau a été |
|    |interrogé, les couples qui ont refusé, etc…                                           |
|    |                                                                                      |
|    |select                                                                                |
|    |t1.event,                                                                             |
|    |t2.event,                                                                             |
|    |count(*)                                                                              |
|    |from                                                                                  |
|    |lentus as t1,                                                                         |
|    |lentus as t2,                                                                         |
|    |twin_project as tp                                                                    |
|    |where                                                                                 |
|    |/* We are looking at one pair at a time */                                            |
|    |t1.id = tp.id                                                                         |
|    |and t1.tvab=tp.tvab                                                                   |
|    |and t1.id = t2.id                                                                     |
|    |/* Just the sceening survey */                                                        |
|    |and tp.survey_no = 5                                                                  |
|    |/* This makes each pair only appear once */                                           |
|    |and t1.tvab='1' and t2.tvab='2'                                                       |
|    |group by                                                                              |
|    |t1.event, t2.event;                                                                   |
|    |9 Serveur MySQL                                                                       |
|    |9.1 Quels sont les langues supportés par MySQL?                                       |
|    |mysqld peut émettre des messages d'erreur dans les langues suivantes : Hollandais,    |
|    |Anglais (par défaut), Estonien, Français, Allemand, Hongrois, Italien, Norvégien,     |
|    |Polonais, Portugais, Espagnol et Suédois.                                             |
|    |Pour démarrer mysqld avec une langue donnée, utilisez l'option --language=lang ou -L  |
|    |lang . Par exemple :                                                                  |
|    |                                                                                      |
|    |shell> mysqld --language=swedish                                                      |
|    |ou:                                                                                   |
|    |                                                                                      |
|    |shell> mysqld --language=/usr/local/share/swedish                                     |
|    |Notez que tous les noms de langues sont spécifiés en minuscules.                      |
|    |Le fichie de langue est situé (par défaut, dans le dossier                            |
|    |`mysql_base_dir/share/LANGUAGE/'.                                                     |
|    |Pour modifier le fichier de message d'erreur, il vous faut éditer le fichier          |
|    |`errmsg.txt' et exécuter la commande suivante pour générer le fichier `errmsg.sys' :  |
|    |                                                                                      |
|    |shell> comp_err errmsg.txt errmsg.sys                                                 |
|    |Si vous mettez à jour MySQL, n'oubliez pas de répeter la même manoeuvre avec le       |
|    |nouveau fichier @new `errmsg.txt'.                                                    |
|    |9.1.1 Le jeu de caractère utilisé pour le tri des données                             |
|    |Par défaut, MySQL utilise le jeu de caractère ISO-8859-1 (Latin1). C'est le jeu de    |
|    |caractères utilisé aux USA et en Europe Occidentale.                                  |
|    |Le jeu de caractères détermine les caractères autorisés dans les noms, et la méthode  |
|    |de tri utilisée dans les clauses ORDER BY et GROUP BY de la commandes SELECT.         |
|    |Vous pouvez changer le jeu de caractères au moment de la compilation, en utilisant    |
|    |l'option --with-charset=charset de configure. 4.7.1 Introduction à l'installation     |
|    |rapide.                                                                               |
|    |Pour ajouter un nouveau jeu de caractères à MySQL, utilisez la procédure suivante :   |
|    |9.1.2 Ajouter un nouveau jeu de caractère                                             |
|    |Choisir un nom pour le jeu de caractère, dénommé MYSET.                               |
|    |Créer le fichier `strings/ctype-MYSET.c' dans la distribution source de MySQL.        |
|    |Regarder dans le fichier `ctype-*.c' pour savoir ce qui doit être défini. Notez que   |
|    |les tableaux de votre fichier doivent avoir des noms du type ctype_MYSET,             |
|    |to_lower_MYSET etc... to_lower[] et to_upper[] sont de simples tableaux qui           |
|    |contiennent les caractères minuscules et majuscules du jeu de caractère. Par exemple :|
|    |                                                                                      |
|    |                                                                                      |
|    |to_lower['A'] doit contenir 'a'                                                       |
|    |to_upper['a'] doit contenir 'A'                                                       |
|    |sort_order[] est une map qui indique comment les caractères doivent être ordonné lors |
|    |des comparaisons et des tris. Pour la plus part des jeux de caractères, c'est la même |
|    |valeur que pour to_upper[] (ce qui signifie que le tri sera insensible à la casse).   |
|    |MySQL effectuera les tris en se basant sur la valeur de sort_order[character]. ctype[]|
|    |est un tableau de valeurs de bit, avec un élément par caractère. (Notez que           |
|    |to_lower[], to_upper[] et sort_order[] sont indexés par valeur de caractère, mais que |
|    |ctype[] est indexé par valeur de caractère +1. C'est une vieille technique qui permet |
|    |de gérer les EOF). Vous pouvez trouver la définitions de ces champs de bit dans       |
|    |`m_ctype.h':                                                                          |
|    |                                                                                      |
|    |#define _U      01      /* Majuscule */                                               |
|    |#define _L      02      /* Minuscule */                                               |
|    |#define _N      04      /* Chiffre */                                                 |
|    |#define _S      010     /* Espacement*/                                               |
|    |#define _P      020     /* Ponctuation */                                             |
|    |#define _C      040     /* Caractère de contrôle */                                   |
|    |#define _B      0100    /* Blanc */                                                   |
|    |#define _X      0200    /* Chiffre hexadécimal */                                     |
|    |L'entrée de ctype[] pour chaque caractère doit être l'union des masques de bits qui   |
|    |décrivent le caractère. Par exemple, 'A' est une caractère majuscule, (_U) mais aussi |
|    |un chiffre hexadécimal. (_X), donc son type devrait contenir ctype['A'+1]             |
|    |                                                                                      |
|    |_U + _X = 01 + 0200 = 0201                                                            |
|    |Ajouter un numéro unique pour votre jeu de caractères dans `include/m_ctype.h.in'.    |
|    |Ajouter le nom du jeu de caractère dans la liste CHARSETS_AVAILABLE de configure.in.  |
|    |Reconfigurer, recompiler et tester.                                                   |
|    |9.1.3 Support des caractères multi-byte                                               |
|    |Si vous créez un jeu de caractères multi byte, vous pouvez utiliser la macro _MB. Dans|
|    |le fichier `include/m_ctype.h.in', ajouter :                                          |
|    |                                                                                      |
|    |#define MY_CHARSET_MYSET  X                                                           |
|    |#if MY_CHARSET_CURRENT == MY_CHARSET_MYSET                                            |
|    |#define USE_MB                                                                        |
|    |#define USE_MB_IDENT                                                                  |
|    |#define ismbchar(p, end)  (...)                                                       |
|    |#define ismbhead(c)       (...)                                                       |
|    |#define mbcharlen(c)      (...)                                                       |
|    |#define MBMAXLEN          N                                                           |
|    |#endif                                                                                |
|    |o√π :                                                                                  |
|    |MY_CHARSET_MYSET                                                                      |
|    |Une valeur de jeu de caractère unique.                                                |
|    |                                                                                      |
|    |USE_MB                                                                                |
|    |Ce jeu de caractère a des caractères multi-byte, géré par ismbhead() et mbcharlen()   |
|    |                                                                                      |
|    |USE_MB_IDENT                                                                          |
|    |(optionnel) Si défini, vous pouvez utiliser des noms de tables et de colonnes avec des|
|    |caractères multi bytes.                                                               |
|    |                                                                                      |
|    |ismbchar(p, e)                                                                        |
|    |retourne 0 si p ne contient pas de caractère multi-byte , ou bien la taille des       |
|    |caractères (en octets). p et e pointent au début et à la fin de la chaîne. Vérifier de|
|    |(char*)p à (char*)e-1.                                                                |
|    |                                                                                      |
|    |ismbhead(c)                                                                           |
|    |Vrai (Trueà si c est le premier caractère d'une chaîne multi-byte.                    |
|    |                                                                                      |
|    |mbcharlen(c)                                                                          |
|    |Taille d'une chaîne multi-byte si c est le premier caractère d'une chaîne.            |
|    |                                                                                      |
|    |MBMAXLEN                                                                              |
|    |Taille en byte du plus grand caractère du jeu de caractère.                           |
|    |                                                                                      |
|    |9.2 Historique de modification                                                        |
|    |When started with the --log-update=file_name option, mysqld writes a log file         |
|    |containing all SQL commands that update data. The file is written in the data         |
|    |directory and has a name of file_name.#, where # is a number that is incremented each |
|    |time you execute mysqladmin refresh or mysqladmin flush-logs, the FLUSH LOGS          |
|    |statement, or restart the server.                                                     |
|    |If you use the --log or -l options, the filename is `hostname.log', and restarts and  |
|    |refreshes do not cause a new log file to be generated. By default, the mysql.server   |
|    |script starts the MySQL server with the -l option. If you need better performance when|
|    |you start using MySQL in a production environment, you can remove the -l option from  |
|    |mysql.server.                                                                         |
|    |Update logging is smart since it logs only statements that really update data. So an  |
|    |UPDATE or a DELETE with a WHERE that finds no rows is not written to the log. It even |
|    |skips UPDATE statements that set a column to the value it already has.                |
|    |If you want to update a database from update log files, you could do the following    |
|    |(assuming your log files have names of the form `file_name.#'):                       |
|    |                                                                                      |
|    |shell> ls -1 -t -r file_name.[0-9]* | xargs cat | mysql                               |
|    |ls is used to get all the log files in the right order.                               |
|    |This can be useful if you have to revert to backup files after a crash and you want to|
|    |redo the updates that occurred between the time of the backup and the crash.          |
|    |You can also use the update logs when you have a mirrored database on another host and|
|    |you want to replicate the changes that have been made to the master database.         |
|    |9.3 Taille des tables MySQL                                                           |
|    |MySQL itself has a 4G limit on table size, and operating systems have their own file  |
|    |size limits. On Linux, the current limit is 2G; on Solaris 2.5.1, the limit is 4G; on |
|    |Solaris 2.6, the limit is going to be 1000G. Currently, table sizes are limited to    |
|    |either 4G (the MySQL limit) or the operating system limit, whichever is smaller. To   |
|    |get more than 4G requires some changes to MySQL that are on the TODO. F Liste de voeux|
|    |pour les versions futures de MySQL (la TODO).                                         |
|    |If your big table is going to be read-only, you could use pack_isam to merge and      |
|    |compress many tables to one. pack_isam usually compresses a table by at least 50%, so |
|    |you can have, in effect, much bigger tables. pack_isam.                               |
|    |Another solution can be the included MERGE library, which allows you to handle a      |
|    |collection of identical tables as one. (Identical in this case means that all tables  |
|    |are created with identical column information.) Currently MERGE can only be used to   |
|    |scan a collection of tables because it doesn't support indexes. We will add indexes to|
|    |this in the near future.                                                              |
|    |10 Améliorer les performances de MySQL                                                |
|    |10.1 Optimisation des valeurs du serveur                                              |
|    |Vous pouvez accéder aux tailles par défaut des buffers de mysqld avec la commande     |
|    |suivante :