Chapitre 8. MySQL Scripts clients et utilitaires
Précédent |  | Suivant

## Chapitre 8. MySQL Scripts clients et utilitaires

Il y a de nombreux programmes clients de MySQL, qui se connectent au serveur pour accéder aux bases ou effectuer des opérations administratives. D'autres utilitaires sont aussi disponibles. Ils ne communiquent pas avec le serveur, mais effectuent des opérations liées à MySQL.

Ce chapitre fournit un bref aper¸u de ces programmes, et vous en dit plus long sur le fonctionnement de chacun. Les descriptions indiquent comment invoquer les programmes, et quelles options ils comprennent. Voyez Chapitre 4, Utiliser les programmes MySQL pour des informations plus générales sur les programmes et leur options.

## 8.1. Présentation des scripts serveurs et utilitaires

Voici une brève liste des scripts et utilitaires pour le serveur :

- `myisampack`

  Un utilitaire qui compresse les tables `MyISAM` pour produire des tables en lecture seule très compactes. See Section 8.2, « `myisampack`, le générateur de tables MySQL compressées en lecture seule ».

- `mysql`

  Le client en ligne de commande, pour envoyer des requêtes à MySQL, interactivement, ou en batch. See Section 8.3, « `mysql`, l'outil en ligne de commande ».

- `mysqlaccess`

  Un script qui vérifie les droits d'accès du trio hôte, utilisateur et base de données.

- `mysqladmin`

  Un utilitaire pour réaliser des opérations d'administration de la base, telles que les créations de bases, le rafraîchissement des tables de droits, l'écriture des tables sur le disque et la réouverture des fichiers de log. à `mysqladmin` permet aussi de lire la version, les processus et les informations de statut du serveur. See Section 8.4, « `mysqladmin`, administration d'un serveur MySQL ».

- `mysqlbinlog`

  Utilitaire de lecture des requêtes au format binaire. Peut être utilisé après un crash, sur une vieille sauvegarde. See Section 8.5, « `mysqlbinlog`, Exécuter des requêtes dans le log binaire ».

- `mysqlcc`

  Interface graphique avec le serveur MySQL. See Section 8.6, « `mysqlcc`, MySQL Control Center ».

- `mysqlcheck`

  Un client d'entretien de tables, qui vérifie, répare, analyse et optimise les tables. See Section 8.7, « Utiliser `mysqlcheck` pour l'entretien et la réparation ».

- `mysqldump`

  Exporte une base de données MySQL dans un fichier sous la forme de requêtes SQL, ou de fichiers texte, avec la tabulation comme séparateur. Un freeware amélioré, d'après une idée originale de Igor Romanenko. See Section 8.8, « `mysqldump`, sauvegarde des structures de tables et les données ».

- `mysqlhotcopy`

  Un utilitaire qui fait des sauvegardes rapides des tables `MyISAM` et `ISAM` alors que le serveur fonctionne. See Section 8.9, « `mysqlhotcopy`, copier les bases et tables MySQL ».

- `mysqlimport`

  Importe les fichiers textes dans les tables, en utilisant la commande `LOAD DATA INFILE`. See Section 8.10, « `mysqlimport`, importer des données depuis des fichiers texte ».

- `mysqlshow`

  See Section 8.11, « Afficher les bases, tables et colonnes ».

- `perror`

  Un utilitaire qui affiche la signification des codes d'erreur MySQL. See Section 8.12, « `perror`, expliquer les codes d'erreurs ».

- `replace`

  `replace` modifie des chaînes dans des fichiers, ou sur l'entrée standard. See Section 8.13, « L'utilitaire de remplacement de chaînes `replace` ».

Chaque programme MySQL accepte différentes options. Mais chaque programme dispose de l'option `--help` qui vous donne une description complète des options du programme. Par exemple, `mysql --help`.

Les clients MySQL qui communiquent avec le serveur, utilisent la bibliothèque `mysqlclient` est les variables d'environnements suivantes :

`MYSQL_UNIX_PORT` | Le fichier de socket Unix par défaut. Utilisé pour les connexions à `localhost`
`MYSQL_TCP_PORT` | Le port par défaut. Utilisé par les connexions TCP/IP.
`MYSQL_PWD` | Le mot de passe par défaut.
`MYSQL_DEBUG` | Les options de débogage.
`TMPDIR` | Le dossier où les tables et fichiers temporaires sont placés.

Utiliser `MYSQL_PWD` n'est pas sécuritaire, et est fortement déconseillé. See Section 5.6.6, « Garder vos mots de passe en lieu sûr ».

Vous pouvez remplacer les valeurs par défaut des options en spécifiant les valeurs dans un fichier d'options, ou en ligne de commande. Section 4.3, « Spécifier des options aux programmes ».

## 8.2. `myisampack`, le générateur de tables MySQL compressées en lecture seule

`myisampack` sert à compresser des tables MyISAM et `pack_isam` sert à compresser les tables ISAM. Comme les tables ISAM sont obsolètes, nous ne traiterons que de `myisampack`, mais tout ce qui est dit au sujet de `myisampack` est aussi vrai pour `pack_isam`.

`myisampack` fonctionne en compressant séparément chaque colonne de la table. Les informations nécessaires à la décompression sont lues en mémoire lorsque la table est ouverte. Cela donne de bien meilleures performances lors de l'accès à des lignes individuelles, car nous n'avez qu'à décompresser exactement une des lignes, et non pas un bloc de disque entier. Généralement, `myisampack` compresse le fichier avec un gain de 40 à 70 %.

MySQL utilise la carte mémoire (`mmap()`) sur les tables compressées et utilise les outils classiques de lecture et écriture si `mmap()` ne fonctionne pas.

Notez bien ceci :

- Si `mysqld` a été appelé avec l'option `--skip-external-locking`, ce n'est pas une bonne idée que d'appeler `myisampack` si la table risque d'être mise à jour par le processus principal.

- Après avoir compressé la table, celle-ci n'est plus accessible qu'en lecture. C'est souvent un état voulu (par exemple, pour être gravée sur un CD). De plus, autoriser les écritures dans une table compressée fait partie de notre liste de tâche, mais avec une très faible priorité.

- `myisampack` peut aussi compresser des colonnes `BLOB` ou `TEXT`. L'ancien `pack_isam` (pour les tables `ISAM`) ne peut le faire.

`myisampack` est invoqué comme ceci :

    shell> myisampack [options] filename ...

Chaque nom de fichier doit être le nom d'un fichier d'index (`.MYI`). Si vous n'êtes pas dans le dossier de données, vous devez spécifier le chemin complet jusqu'au fichier. Il est toléré que vous omettiez l'extension du fichier `.MYI`.

`myisampack` supporte les options suivantes :

- `--help, -?`

  Affiche le message d'aide et quitte.

- `--backup, -b`

  Fait une sauvegarde de la table sous le nom de `tbl_name.OLD`.

- `--debug[=debug_options], -# [debug_options]`

  Affiche le log de débogage. La chaîne `debug_options` vaut souvent `'d:t:o,filename'`.

- `--force, -f`

  Force la compression de la table, même si elle grossit ou si le fichier temporaire existe déjà. `myisampack` crée un fichier temporaire appelé `tbl_name.TMD` lors de la compression. Si vous tuez `myisampack`, le fichier `.TMD` peut ne pas être effacé. Normalement, `myisampack` se termine avec une erreur s'il découvre que le fichier `tbl_name.TMD` existe. Avec `--force`, `myisampack` reprendra le travail.

- `--join=big_tbl_name, -j big_tbl_name`

  Rassemble toutes les tables indiquées dans la ligne de commande dans une seule table appelée `big_tbl_name`. Toutes les tables qui seront combinées doivent être identiques (mêmes noms de colonnes, mêmes types, mêmes index, etc.)

- `--packlength=#, -p #`

  Spécifie la taille de stockage de la longueur de ligne, en octets. Cette valeur doit être 1, 2, ou 3. (`myisampack` stocke toutes les lignes avec des pointeurs de lignes de 1, 2 ou 3 octets. Dans les cas normaux, `myisampack` peut déterminer la taille correcte avant de compresser le fichier, mais il peut aussi se rendre compte durant le processus qu'une autre taille aurait été plus appropriée, ou plus courte. Dans ce cas, `myisampack` va imprimer une note pour que vous le sachiez lors de la prochaine compression du même fichier.

- `--silent, -s`

  Mode silencieux. Seules les erreurs seront affichées.

- `--test, -t`

  Ne compresse pas la table, mais teste juste la compression.

- `--tmp_dir=path, -T path`

  Utilise le dossier indiqué comme dossier pour les fichiers temporaires.

- `--verbose, -v`

  Mode détaillé. Toutes les informations sur la progression de la compression seront affichées.

- `--version, -V`

  Affiche la version et quitte.

- `--wait, -w`

  Attend et reessaie, si la table était déjà en cours d'utilisation. Si le serveur `mysqld` a été démarré avec l'option `--skip-external-locking`, ce n'est pas une bonne idée d'appeler `myisampack`, car la table risque d'être modifiée durant la compression.

La séquence de commande illustre la session de compression :

    shell> ls -l station.*
    -rw-rw-r--   1 monty    my         994128 Apr 17 19:00 station.MYD
    -rw-rw-r--   1 monty    my          53248 Apr 17 19:00 station.MYI
    -rw-rw-r--   1 monty    my           5767 Apr 17 19:00 station.frm

    shell> myisamchk -dvv station

    MyISAM file:     station
    Isam-version:  2
    Creation time: 1996-03-13 10:08:58
    Recover time:  1997-02-02  3:06:43
    Data records:              1192  Deleted blocks:              0
    Datafile: Parts:           1192  Deleted data:                0
    Datafile pointer (bytes):     2  Keyfile pointer (bytes):     2
    Max datafile length:   54657023  Max keyfile length:   33554431
    Recordlength:               834
    Record format: Fixed length

    table description:
    Key Start Len Index   Type                       Root  Blocksize    Rec/key
    1   2     4   unique  unsigned long              1024       1024          1
    2   32    30  multip. text                      10240       1024          1

    Field Start Length Type
    1     1     1
    2     2     4
    3     6     4
    4     10    1
    5     11    20
    6     31    1
    7     32    30
    8     62    35
    9     97    35
    10    132   35
    11    167   4
    12    171   16
    13    187   35
    14    222   4
    15    226   16
    16    242   20
    17    262   20
    18    282   20
    19    302   30
    20    332   4
    21    336   4
    22    340   1
    23    341   8
    24    349   8
    25    357   8
    26    365   2
    27    367   2
    28    369   4
    29    373   4
    30    377   1
    31    378   2
    32    380   8
    33    388   4
    34    392   4
    35    396   4
    36    400   4
    37    404   1
    38    405   4
    39    409   4
    40    413   4
    41    417   4
    42    421   4
    43    425   4
    44    429   20
    45    449   30
    46    479   1
    47    480   1
    48    481   79
    49    560   79
    50    639   79
    51    718   79
    52    797   8
    53    805   1
    54    806   1
    55    807   20
    56    827   4
    57    831   4

    shell> myisampack station.MYI
    Compressing station.MYI: (1192 records)
    - Calculating statistics

    normal:     20  empty-space:      16  empty-zero:        12  empty-fill:  11
    pre-space:   0  end-space:        12  table-lookups:      5  zero:         7
    Original trees:  57  After join: 17
    - Compressing file
    87.14%

    shell> ls -l station.*
    -rw-rw-r--   1 monty    my         127874 Apr 17 19:00 station.MYD
    -rw-rw-r--   1 monty    my          55296 Apr 17 19:04 station.MYI
    -rw-rw-r--   1 monty    my           5767 Apr 17 19:00 station.frm

    shell> myisamchk -dvv station

    MyISAM file:     station
    Isam-version:  2
    Creation time: 1996-03-13 10:08:58
    Recover time:  1997-04-17 19:04:26
    Data records:              1192  Deleted blocks:              0
    Datafile: Parts:           1192  Deleted data:                0
    Datafilepointer (bytes):      3  Keyfile pointer (bytes):     1
    Max datafile length:   16777215  Max keyfile length:     131071
    Recordlength:               834
    Record format: Compressed

    table description:
    Key Start Len Index   Type                       Root  Blocksize    Rec/key
    1   2     4   unique  unsigned long             10240       1024          1
    2   32    30  multip. text                      54272       1024          1

    Field Start Length Type                         Huff tree  Bits
    1     1     1      constant                             1     0
    2     2     4      zerofill(1)                          2     9
    3     6     4      no zeros, zerofill(1)                2     9
    4     10    1                                           3     9
    5     11    20     table-lookup                         4     0
    6     31    1                                           3     9
    7     32    30     no endspace, not_always              5     9
    8     62    35     no endspace, not_always, no empty    6     9
    9     97    35     no empty                             7     9
    10    132   35     no endspace, not_always, no empty    6     9
    11    167   4      zerofill(1)                          2     9
    12    171   16     no endspace, not_always, no empty    5     9
    13    187   35     no endspace, not_always, no empty    6     9
    14    222   4      zerofill(1)                          2     9
    15    226   16     no endspace, not_always, no empty    5     9
    16    242   20     no endspace, not_always              8     9
    17    262   20     no endspace, no empty                8     9
    18    282   20     no endspace, no empty                5     9
    19    302   30     no endspace, no empty                6     9
    20    332   4      always zero                          2     9
    21    336   4      always zero                          2     9
    22    340   1                                           3     9
    23    341   8      table-lookup                         9     0
    24    349   8      table-lookup                        10     0
    25    357   8      always zero                          2     9
    26    365   2                                           2     9
    27    367   2      no zeros, zerofill(1)                2     9
    28    369   4      no zeros, zerofill(1)                2     9
    29    373   4      table-lookup                        11     0
    30    377   1                                           3     9
    31    378   2      no zeros, zerofill(1)                2     9
    32    380   8      no zeros                             2     9
    33    388   4      always zero                          2     9
    34    392   4      table-lookup                        12     0
    35    396   4      no zeros, zerofill(1)               13     9
    36    400   4      no zeros, zerofill(1)                2     9
    37    404   1                                           2     9
    38    405   4      no zeros                             2     9
    39    409   4      always zero                          2     9
    40    413   4      no zeros                             2     9
    41    417   4      always zero                          2     9
    42    421   4      no zeros                             2     9
    43    425   4      always zero                          2     9
    44    429   20     no empty                             3     9
    45    449   30     no empty                             3     9
    46    479   1                                          14     4
    47    480   1                                          14     4
    48    481   79     no endspace, no empty               15     9
    49    560   79     no empty                             2     9
    50    639   79     no empty                             2     9
    51    718   79     no endspace                         16     9
    52    797   8      no empty                             2     9
    53    805   1                                          17     1
    54    806   1                                           3     9
    55    807   20     no empty                             3     9
    56    827   4      no zeros, zerofill(2)                2     9
    57    831   4      no zeros, zerofill(1)                2     9

Les informations affichées par `myisampack` sont décrites ici :

- `normal`

  Le nombre de colonnes pour lesquelles aucune compression n'est utilisée.

- `empty-space`

  Le nombre de colonnes dont les valeurs ne contiennent que des octets : elles n'occuperont plus qu'un octet.

- `empty-zero`

  Le nombre de colonnes dont les valeurs ne contiennent que des zéros : elles n'occuperont plus qu'un octet.

- `empty-fill`

  Le nombre de colonnes de type entier qui n'occupent pas la totalité de l'espace de leur type. Elles seront réduites en taille (par exemple, une colonne de type `INTEGER` sera transformée en `MEDIUMINT`).

- `pre-space`

  Le nombre de colonnes de nombres à virgule flottante qui ont des valeurs stockées avec des espaces initiaux. Dans ce cas, chaque valeur va contenir le nombre d'espace initiaux.

- `end-space`

  Le nombre de colonnes qui ont de nombreux espaces terminaux. Dans ce cas, chaque valeur va contenir un compte du nombre d'espaces terminaux.

- `table-lookup`

  La colonne n'a que quelques valeurs différentes, qui seront converties en une colonne de type `ENUM` avant une compression de type Huffman.

- `zero`

  Le nombre de colonnes pour lesquelles toutes les valeurs sont zéro.

- `Original trees`

  Le nombre initial d'arbres Huffman.

- `After join`

  Le nombre d'arbres Huffman distincts obtenus après avoir joint les arbres pour économiser de l'espace d'entête.

Après la compression d'une table, `myisamchk -dvv` affiche des informations supplémentaires pour chaque champ :

- `Type`

  Le type de fichier peut contenir les informations suivantes :

  - `constant`

    Toutes les lignes ont la même valeur.

  - `no endspace`

    Ne stocke pas les espaces finaux.

  - `no endspace, not_always`

    Ne stocke pas les espaces finaux et ne compresse pas les espaces finaux pour toutes les valeurs.

  - `no endspace, no empty`

    Ne stocke pas les espaces finaux. Ne stocke pas les valeurs vides.

  - `table-lookup`

    La colonne a été convertie en `ENUM`.

  - `zerofill(n)`

    Les `n` chiffres significatifs sont toujours 0, et n'ont pas été stockés.

  - `no zeros`

    Ne stocke pas les zéros.

  - `always zero`

    Les valeurs 0 sont stockées sur un octet.

- `Huff tree`

  L'arbre Huffman associé au champ.

- `Bits`

  Le nombre de bits utilisés par l'arbre Huffman.

Après la compression de `pack_isam`/`myisampack` vous devez exécuter la commande `isamchk`/`myisamchk` pour recréer l'index. A ce moment, vous pouvez aussi trier les blocs d'index et créer des statistiques nécessaires pour l'optimiseur MySQL :

    shell> myisamchk -rq --sort-index --analyze tbl_name.MYI

Une procédure similaire s'applique aux tables `ISAM`. Après avoir utilisé `pack_isam`, utilisez `isamchk` pour recréer les index :

    shell> isamchk -rq --sort-index --analyze tbl_name.ISM

Après avoir installé la table compressée dans un dossier de données MysQL, vous devez exécutez la commande `mysqladmin flush-tables` pour forcer `mysqld` à utiliser cette nouvelle table.

Si vous voulez décompresser une table compressée, vous pouvez le faire avec l'option `--unpack` de la commande `isamchk` ou `myisamchk`.

## 8.3. `mysql`, l'outil en ligne de commande

`mysql` est un simple script SQL (qui exploite `GNU` `readline`). Il supporte une utilisation interactive et non-interactive. Lorsqu'il est utilisé interactivement, les résultats des requêtes sont présentés sous la forme d'une table au format ASCII. Lorsqu'il est utilisé non-interactivement, par exemple, comme filtre, le résultat est fourni au format de liste avec séparation par tabulation (le format d'affichage peut être modifié en utilisant les options de ligne de commande).

Si vous avez des problèmes liés à des insuffisances de mémoire avec le client, utilisez l'option `--quick`! Cela force `mysql` à utiliser `mysql_use_result()` plutôt que `mysql_store_result()` pour lire les résultats.

Utiliser `mysql` est très simple. Il suffit de le démarrer comme ceci :

    shell> mysql db_name

ou :

    shell> mysql --user=user_name --password=your_password db_name

Tapez une commande SQL, puis terminez-la avec ‘`;`’, ‘`\g`’ ou ‘`\G`’, et finissez avec entrée.

Vous pouvez exécuter un script avec :

    shell> mysql db_name < script.sql > output.tab

`mysql` supporte les options suivantes :

- `--help, -?`

  Affiche cette aide et quitte.

- `--batch, _B`

  Affiche les résultats avec une tabulation comme résultat, et chaque ligne avec une nouvelle ligne. N'utilise pas l'historique.

- `--character-sets-dir=path`

  Le dossier où les jeux de caractères sont créés. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--compress, _C`

  Utilise la compression avec le protocole client / serveur.

- `--database=db_name, -D db_name`

  La base de données à utiliser. C'est particulièrement pratique dans le fichier d'options `my.cnf`.

- `--debug[=debug_options], -# [debug_options]`

  Génère un log de débogage. La chaîne `debug_options` vaut souvent `'d:t:o,file_name'`. Par défaut, la valeur est `'d:t:o,/tmp/mysql.trace'`.

- `--debug-info, -T`

  Affiche des informations de débogage lorsque le programme se termine.

- `--default-character-set=charset`

  Configure le jeu de caractères par défaut. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--execute=statement, -e statement`

  Exécute une commande et quitte. Le résultat est au format de l'option `--batch`.

- `--force, f`

  Continue même si vous recevez une erreur SQL.

- `--host=host_name, -h host_name`

  Connexion avec l'hôte indiqué.

- `--html, H`

  Produit un résultat au format HTML.

- `--ignore-space, i`

  Ignore les espaces après les noms de fonctions. L'effet de cette commande est décrit dans la discussion sur `IGNORE_SPACE` de la section Section 5.2.2, « Le mode SQL du serveur ».

- `--local-infile[={0|1}]`

  Active ou désactive la possibilité d'utiliser la commande `LOCAL` pour `LOAD DATA INFILE`. Sans valeur, cette option active `LOCAL`. Elle peut être configuré avec `--local-infile=0` ou `--local-infile=1` pour explicitement activer ou désactiver `LOCAL`. Activer `LOCAL` n'a pas d'effet si le serveur ne le supporte pas de son coté.

- `--named-commands, -G`

  Les commandes nommées sont activées. Utilisez la forme `\*` uniquement, ou utilisez les commandes nommées au début d'une ligne se terminant par un point-virgule (‘`;`’). Depuis la version 10.9, le client démarre avec cette option activée par défaut. Avec l'option `-g`, le format long des commandes va continuer à fonctionner.

- `--no-auto-rehash, -A`

  Pas de rehashage automatique. Cette option fait que `mysql` se lance plus rapidement, mais vous devez utiliser la commande `rehash` si vous voulez utiliser la completion de nom de tables.

- `--no-beep, -b`

  Ne fait pas de bip, lorsqu'une erreur survient.

- `--no-named-commands, -g`

  Les commandes nommées sont désactivées. Utilisez uniquement la forme `\*` ou bien utilisez les commandes nommées en début de ligne, et terminez la avec un point-virgule (‘`;`’). Depuis MySQL 3.23.22, `mysql` démarre avec cette option activée par défaut! Cependant, même si cette avec cette option, les formats de commandes longues fonctionneront sur la première ligne.

- `--no-pager`

  Désactive le système de page, et affiche directement dans la sortie standard. Plus de détails dans la section Section 8.3.1, « Commandes `mysql` ».

- `--no-tee`

  Désactive le fichier de sortie. Voyez l'aide interactive (\h). Plus de détails dans la section Section 8.3.1, « Commandes `mysql` ».

- `--one-database, O`

  Ne modifie que la base par défaut. C'est pratique pour éviter les modifications dans les autres bases dans le fichier de log.

- `--pager[=command]`

  Type d'affichage. Par défaut, la variable d'environnement `ENV` vaut `PAGER`. Les pagineurs valides sont `less`, `more`, `cat [> filename]`, etc. Voyez l'aide interactive (`\h`). Cette option n'est pas fonctionnelle en mode batch. Les pagineurs ne fonctionnent qu'avec Unix. Plus de détails dans la section Section 8.3.1, « Commandes `mysql` ».

- `--password[=password], -p[password]`

  Le mot de passe utilisé lors de la connexion sur le serveur. S'il n'est pas donné en ligne de commande, il sera demandé interactivement. Notez que si vous utilisez la forme courte `-p`, vous ne devez pas laisser d'espace entre l'option et le mot de passe.

- `--port=port_num, -P port_num`

  Le numéro de port TCP/IP pour la connexion.

- `--prompt=format_str`

  Modifie le format de l'invite de commandes (`prompt`). Par défaut, c'est `mysql>`. Les séquences spéciales sont présentées dans la section Section 8.3.1, « Commandes `mysql` ».

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Spécifie le protocole de connexion à utiliser. Nouveau en MySQL version 4.1.

- `--quick, -q`

  Ne met pas en cache le résultat, et l'affiche ligne par ligne. C'est plus lent pour le serveur, si le résultat est interrompu. N'utilise pas le fichier d'historique.

- `--raw, -r`

  Ecrit les valeurs des colonnes sans les conversions de protections. Utilisé en mode `--batch`

- `--reconnect`

  Si la connexion est perdue, essaie de se reconnecter automatiquement au serveur, juste une fois. Pour supprimer la reconnexion automatique, utilisez `--skip-reconnect`. Nouveau en MySQL 4.1.0.

- `--safe-updates, --i-am-a-dummy, -U`

  N'autorise que les commandes `UPDATE` et `DELETE` qui utilisent des clés. Voir plus bas pour des informations sur cette option. Vous pouvez annuler cette option si vous l'avez dans le fichier d'option `my.cnf` en utilisant la syntaxe `--safe-updates`. Voyez la section Section 8.3.3, « Conseils avec `mysql` » pour plus d'informations sur cette option.

- `--silent, -s`

  Mode très silencieux.

- `----skip-column-names, -N`

  N'écrit pas les noms de colonnes dans les résultats.

- `--skip-line-numbers, -L`

  N'écrit pas les numéros de lignes dans les erreurs. Très pratique lorsque vous voulez comparer des résultats qui incluent des messages d'erreurs.

- `--socket=path, -S path`

  Le fichier de socket à utiliser pour la connexion.

- `--table, -t`

  Affichage au format de table. C'est le mode par défaut pour le mode non-batch.

- `--tee=file_name`

  Ajoute tout dans le fichier de sortie. Voyez l'aide interactive (\h). Ne fonctionne pas en mode batch. Cette option est détaillée dans Section 8.3.1, « Commandes `mysql` ».

- `--unbuffered, -n`

  Vide le buffer de requête après chaque requête.

- `--user=user_name, -u user_name`

  Nom d'utilisateur pour la connexion, si ce n'est pas l'utilisateur Unix courant.

- `--verbose, -v`

  Affichage plus détaillé (`-v -v -v` indique le format d'affichage de table).

- `--version, -V`

  Affiche la version et quitte.

- `--vertical, -E`

  Affiche le résultat d'une requête verticalement. Sans cette option, vous pouvez aussi obtenir ce format en terminant votre requête avec `\G`.

- `--wait, -w`

  Attend et retente si la connexion s'interrompt, au lieu de quitter.

- `--xml, -X`

  Affiche le résultat au format XML.

Vous pouvez aussi spécifier les variables suivantes avec la syntaxe `--var=option` :

- `connect_timeout`

  Nombre de secondes avant que la connexion n'expire. Valeur par défaut : 0.

- `max_allowed_packet`

  Taille maximale du paquet de communication avec le serveur. Valeur par défaut : 16777216.

- `max_join_size`

  Limite automatique pour les commandes de jointure avec l'option `--i-am-a-dummy`. Valeur par défaut : 1 000 000 (un million).

- `net_buffer_length`

  Buffer pour les communications TCP/IP et socket. Valeur par défaut : 16 ko.

- `select_limit`

  Limite automatique pour les commandes `SELECT` avec l'option `--i-am-a-dummy` Valeur par défaut : 1000.

Il est aussi possible de configurer les variables en utilisant `--set-variable=var_name=value` ou la syntaxe `-O var_name=value`. Cependant, cette syntaxe est obsolète depuis MySQL 4.0.

Sous Unix, le client `mysql` écrit l'historique des requêtes dans un fichier. Par défaut, le fichier de requêtes s'appelle `.mysql_history`, et il est créé dans votre dossier racine. Pour spécifier un fichier différent, modifiez la variable d'environnement `MYSQL_HISTFILE`.

Si vous ne voulez pas entretenir un fichier d'historiques, supprimez `.mysql_history` s'il existe, puis utiliser l'une des techniques suivantes :

- Donnez à `MYSQL_HISTFILE` la valeur de `/dev/null`. Pour que cela soit pris en compte à chaque redémarrage, ajoutez cette ligne à votre script de démarrage.

- Faites un lien symbolique depuis `.mysql_histfile` vers `/dev/null`:

      shell> ln -s /dev/null $HOME/.mysql_history

  Il suffira de faire cela une seule fois.

### 8.3.1. Commandes `mysql`

`mysql` envoie des requêtes SQL que vous avez saisie au serveur, pour exécution. Il y a aussi des commandes que le client `mysql` interprête. Si vous tapez ‘`help`’ en ligne de commande, `mysql` va afficher les commandes qu'il supporte :

    mysql> help

    MySQL commands:
    ?         (\h)    Synonym for `help'.
    clear     (\c)    Clear command.
    connect   (\r)    Reconnect to the server.
                      Optional arguments are db and host.
    delimiter (\d)    Set query delimiter.
    edit      (\e)    Edit command with $EDITOR.
    ego       (\G)    Send command to mysql server,
                      display result vertically.
    exit      (\q)    Exit mysql. Same as quit.
    go        (\g)    Send command to mysql server.
    help      (\h)    Display this help.
    nopager   (\n)    Disable pager, print to stdout.
    notee     (\t)    Don't write into outfile.
    pager     (\P)    Set PAGER [to_pager].
                      Print the query results via PAGER.
    print     (\p)    Print current command.
    prompt    (\R)    Change your mysql prompt.
    quit      (\q)    Quit mysql.
    rehash    (\#)    Rebuild completion hash.
    source    (\.)    Execute an SQL script file.
                      Takes a file name as an argument.
    status    (\s)    Get status information from the server.
    system    (\!)    Execute a system shell command.
    tee       (\T)    Set outfile [to_outfile].
                      Append everything into given outfile.
    use       (\u)    Use another database.
                      Takes database name as argument.

Les commandes `edit`, `nopager`, `pager` et `system` ne fonctionnent que sous Unix.

La commande `status` donne des détails sur la connexion et le serveur utilisés. Si vous fonctionnez en mode `--safe-updates`, `status` va aussi afficher les valeurs des variables de `mysql` qui affectent vos requêtes.

Pour enregistrer les requêtes et leur résultat, utilisez la commande `tee`. Toutes les données affichées à l'écran seront ajoutées à un fichier donné. Cela peut être très pratique pour déboguer. Vous pouvez activer cette fonctionnalité en ligne de commande, avec l'option `--tee`, ou interactivement avec la commande `tee`. Le fichier `tee` peut être désactivé interactivement avec la commande `notee`. Exécuter `tee` à nouveau ré-active le log. Sans paramètre, le fichier précédent sera utilisé. Notez que `tee` envoie les requêtes dans le fichier après chaque commande, juste avant que `mysql` ne l'affiche.

La lecture et la recherche dans les résultats de requêtes en mode interactif est possible en utilisant les programmes Unix `less`, `more`, ou tout autre programme similaire, avec l'option `--pager`. Si vous ne spécifier par de valeur d'option, `mysql` regarde la valeur de la variable d'environnement `PAGER`, et utilise ce pager. Vous pouvez aussi l'activer interactivement avec la commande `pager` et la désactiver avec `nopager`. La commande prend un argument optionnel : s'il est fournit, le programme de pager indiqué sera utilisé. Sinon, le pager sera celui indiqué en ligne de commande, ou `stdout` si aucun pager n'était indiqué.

La pagination de sortie ne fonctionne que sous Unix, car elle utilise la fonction `popen()`, qui n'existe pas sous Windows. Pour Windows, la commande `tee` peut être utilisée pour sauver le résultat, même si ce n,est pas aussi pratique que `pager` pour naviguer dans le résultat.

Quelques conseils avec la commande `pager` :

- Vous pouvez l'utiliser pour écrire les résultats dans un fichier :

      mysql> pager cat > /tmp/log.txt

  Vous pouvez lui passer les options que le page comprendra :

      mysql> pager less -n -i -S

- Dans le précédent exemple, notez l'option `-S`. Vous la trouverez pratique pour naviguer dans des résultats très larges. Parfois, un résultat très large est difficile à lire à l'écran. L'option `-S` de `less` rend le résultat plus lisible, car vous pouvez aussi scroller horizontalement, avec les flèches de droite et de gauche. Vous pouvez aussi utiliser interactivement `-S` dans `less` pour activer ou désactiver la navigation horizontale. Pour plus d'informations, voyez le manuel de `less` :

      shell> man less

- Vous pouvez spécifier des commandes de pages très complexe :

      mysql> pager cat | tee /dr1/tmp/res.txt \
                | tee /dr2/tmp/res2.txt | less -n -i -S

  Dans cet exemple, la commande va envoyer les résultats de la commande dans deux fichiers différents, dans deux dossiers différents, placés sur deux devis `/dr1` et `/dr2`, mais affichera toujours le résultat à l'écran via `less`.

Vous pouvez aussi combiner les deux fonctions ci-dessus : activer le `tee`, spécifier le `pager` ‘`less`’ et vous serez capable de naviguer dans les résultats avec le `less` Unix, tout en enregistrant tous les résultats dans un fichier. La différence entre le `tee` d'Unix utilisé avec le `pager` et le `tee` intégré du client `mysql`, est que le `tee` intégré fonctionne même si vous n'avez pas de `tee` Unix disponible. Le `tee` enregistre tout ce qui est affiché à l'écran, alors que le `tee` Unix utilisé avec `pager` n'en note pas autant. Enfin, le `tee` interactif est plus facile à activer et désactiver, lorsque vous souhaitez enregistrer un résultat dans un fichier, mais que vous voulez désactiver cette fonctionnalité à d'autres moments.

Depuis MySQL version 4.0.2, il est possible de modifier l'invite de commande de `mysql`. La chaîne de définition de l'invite de commande accepte les séquences suivantes :

Option | Description
`\v` | version de mysqld
`\d` | database en cours
`\h` | hôte MySQL
`\p` | port de connexion
`\u` | nom d'utilisateur
`\U` | Identifiant complet `username@host`
`\\` | ‘`\`’
`\n` | nouvelle ligne
`\t` | tabulation
`\` | espace
`\_` | espace
`\R` | heure 24h (0-23)
`\r` | heure 12h (1-12)
`\m` | minutes
`\y` | année sur deux chiffres
`\Y` | année sur quatre chiffres
`\D` | format de date complet
`\s` | secondes
`\w` | jour de la semaine en trois lettres (Mon, Tue, ...)
`\P` | am/pm
`\o` | mois au format numérique
`\O` | mois en trois lettres (Jan, Feb, ...)
`\c` | compteur du nombre de commande

‘`\`’ suivi de n'importe quelle lettre représente la lettre littéralement.

Si vous spécifiez une commande `prompt` sans argument, `mysql` utilisera l'invite de commande par défaut de `mysql>`.

Vous pouvez modifier l'invite de commande comme ceci :

- Variable d'environnement Vous pouvez utiliser la variable d'environnement `MYSQL_PS1`, en lui donnant la chaîne d'invite. Par exemple :

      shell> export MYSQL_PS1="(\u@\h) [\d]> "

- Utiliser le fichier d'options

  Vous pouvez configurer l'invite de commandes `prompt` dans le fichier d'options MySQL, comme `/etc/my.cnf` ou `.my.cnf`, dans le groupe `mysql`. Par exemple :

      [mysql]
      prompt=(\\u@\\h) [\\d]>\\_

  Dans cet exemple, notez que les anti-slash sont doublés. Si vous configurez l'invite de commande `prompt` dans un fichier d'options, il est recommandé de doubler les anti-slash, lorsque vous utilisez des options. Il y a des recoupements entre les séquences protégées et les options. Ces séquences sont listées dans Section 4.3.2, « Fichier d'options `my.cnf` ». Ce recoupement peut vous causer des problèmes avec des anti-slashs uniques. Par exemple, `\s` sera interprété comme un espace, plutôt que comme le nombre de secondes. La valeur suivante montre comment définir une invite avec l'heure au format `HH:MM:SS>` :

      [mysql]
      prompt="\\r:\\m:\\s> "

- Utilisez une option de ligne de commande

  Vous pouvez utiliser l'option `--prompt` dans la commande `mysql`. Par exemple :

      shell> mysql --prompt="(\u@\h) [\d]> "
      (user@host) [database]>

- Interactivement

  Vous pouvez aussi utiliser la commande `prompt` (ou `\R`) depuis le client pour modifier interactivement l'invite de commande. Par exemple :

      mysql> prompt (\u@\h) [\d]>\_
      PROMPT set to '(\u@\h) [\d]>\_'
      (user@host) [database]>
      (user@host) [database]> prompt
      Returning to default PROMPT of mysql>
      mysql>

### 8.3.2. Comment exécuter des commandes SQL depuis un fichier texte

Le client `mysql` peut être utilisé en mode interactif comme ceci :

    shell> mysql database

Toutefois, il est aussi possible de rassembler les commandes SQL dans un fichier, et d'indiquer à `mysql` de lire les commandes dans ce fichier. Pour faire cela, créez un fichier texte `fichier_texte` qui contient les commandes SQL que vous souhaitez exécuter. Puis, exécutez ce fichier avec `mysql` comme ceci :

    shell> mysql database < fichier_texte

Vous pouvez aussi démarrer votre fichier texte avec la commande `USE nom_base`. Dans ce cas, il n'est pas nécessaire de spécifier le nom de la base de données dans la ligne de commande :

    shell> mysql < fichier_texte

Si vous avez déjà démarré le client `mysql`, vous pouvez exécuter un script SQL en utilisant la commande `source` :

    mysql> source nom_fichier;

Pour plus d'informations sur le mode batch, consultez Section 3.5, « Utilisation de `mysql` en mode batch ».

### 8.3.3. Conseils avec `mysql`

Cette section décrit certaines techniques qui vous aideront à utiliser `mysql` plus efficacement.

#### 8.3.3.1. Affichage des résultats verticalement

Certaines requêtes sont bien plus lisibles une fois affichées verticalement, au lieu de horizontalement. Par exemple, si la taille du texte est bien plus grande que la largeur de l'écran, ou qu'il y a des retours à la ligne, le format vertical est préférable :

    mysql> SELECT * FROM mails WHERE LENGTH(txt) < 300 LIMIT 300,1\G
    *************************** 1. row ***************************
      msg_nro: 3068
         date: 2000-03-01 23:29:50
    time_zone: +0200
    mail_from: Monty
        reply: monty@no.spam.com
      mail_to: "Thimble Smith" <tim@no.spam.com>
          sbj: UTF-8
          txt: >>>>> "Thimble" == Thimble Smith writes:

    Thimble> Hi.  I think this is a good idea.  Is anyone familiar
    Thimble> with UTF-8 or Unicode? Otherwise, I'll put this on my
    Thimble> TODO list and see what happens.

    Yes, please do that.

    Regards,
    Monty
         file: inbox-jani-1
         hash: 190402944
    1 row in set (0.09 sec)

#### 8.3.3.2. Utilisation de l'option `--safe-updates`

Pour les débutants, une option de démarrage pratique est `--safe-updates` (ou `--i-am-a-dummy`, qui a le même effet). Cette option a été introduite en MySQL 3.23.11. Elle est pratique si vous avec émis des commandes `DELETE FROM tbl_name` mais que vous avez oublié la clause `WHERE`. Normalement, une telle commande va effacer toutes les lignes de la table. Avec `--safe-updates`, vous pouvez effacer uniquement les lignes dont vous spécifiez les valeurs de clé pour les identifier. Cela évite les accidents.

Lorsque vous utilisez l'option `--safe-updates`, `mysql` émet l'alerte suivante lorsqu'il se connecte à MySQL :

    SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=1000,
        SQL_MAX_JOIN_SIZE=1000000;

See Section 13.5.2.8, « Syntaxe de `SET` ».

La commande `SET` a l'effet suivant :

- Vous n'êtes pas autorisés à exécuter de commandes `UPDATE` et `DELETE` à moins que vous ne spécifiez une contrainte de clé dans la clause `WHERE` où que vous fournissiez une clause `LIMIT`, ou les deux. Par exemple :

      UPDATE tbl_name SET not_key_column=# WHERE key_column=#;

      UPDATE tbl_name SET not_key_column=# LIMIT 1;

- Tous les résultats importants de `SELECT` sont automatiquement limités à 1000, à moins que la commande n'inclut la clause `LIMIT`.

- Les commandes `SELECT` multi-tables qui devront étudier plus d'un million de lignes sont annulées.

Pour spécifier des limites autres que 1000 et 1000000, vous pouvez remplacer les maxima avec `--select_limit` et `--max_join_size` :

    shell> mysql --safe-updates --select_limit=500 --max_join_size=10000

#### 8.3.3.3. Désactiver la reconnexion automatique de `mysql`

Si le client `mysql` perd la connexion au serveur durant l'envoi d'une requête, il va immédiatement et automatiquement essayer de se reconnecter une fois au serveur, puis essayer d'envoyer à nouveau la requête. Toutefois, même si `mysql` réussit à se reconnecter, l'ancienne connexion a été fermée, et tous les objets temporaires ont été perdus : tables temporaires, configuration en auto_commit, variables utilisateur et de session. Ce comportement peut se révéléer dangeureux pour vous, comme dans l'exemple suivant, où le serveur est stoppé, puis relancé sans que vous le sachiez :

    mysql> SET @a=1;
    Query OK, 0 rows affected (0.05 sec)

    mysql> INSERT INTO t VALUES(@a);
    ERROR 2006: MySQL server has gone away
    No connection. Trying to reconnect...
    Connection id:    1
    Current database: test

    Query OK, 1 row affected (1.30 sec)

    mysql> SELECT * FROM t;
    +------+
    | a    |
    +------+
    | NULL |
    +------+
    1 row in set (0.05 sec)

La variable utilisateur `@a` a été perduée, et lors de la reconnexion, elle est indéfinie. S'il est important que `mysql` génère une erreur lors de la perte de connexion, vous pouvez lancez le client `mysql` avec l'option `--skip-reconnect`.

## 8.4. `mysqladmin`, administration d'un serveur MySQL

`mysqladmin` est un utilitaire pour exécuter des commandes d'administration. Vous pouvez l'utiliser pour vérifier la configuration du serveur, créer et effacer des bases, etc.

La syntaxe de `mysqladmin` est :

    shell> mysqladmin [OPTIONS] command [command-option] command ...

Le `mysqladmin` actuel supporte les commandes suivantes :

- `create databasename`

  Crée une nouvelle base.

- `drop databasename`

  Efface une base et toutes ces tables.

- `extended-status`

  Affiche un message de statut du serveur très complet.

- `flush-hosts`

  Vide tous les hôtes mis en cache.

- `flush-logs`

  Vide de la mémoire tous les logs.

- `flush-privileges`

  Recharger les tables de droits (identique à la commande reload).

- `flush-status`

  Remet à zéro les variables de statut.

- `flush-tables`

  Vide de la mémoire toutes les tables.

- `flush-threads`

  Vide les threads de cache. Nouveau en MySQL 3.23.16.

- `kill id,id,...`

  Termine un thread MySQL.

- `password new-password`

  Spécifie un nouveau mot de passe. Modifie l'ancien mot de passe en `new-password` pour le compte que vous utilisez lors de la connexion avec `mysqladmin`.

- `ping`

  Vérifie si mysqld fonctionne ou pas.

- `processlist`

  Affiche la liste des processus du serveur. Cela revient à la commande `SHOW PROCESSLIST`. Si `--verbose` est utilisé, le résultat est le même que `SHOW FULL PROCESSLIST`.

- `reload`

  Recharge les tables de droits.

- `refresh`

  Vide de la mémoire toutes les tables, puis ferme et réouvre les fichiers de logs.

- `shutdown`

  Eteind le serveur.

- `slave-start`

  Démarre l'esclave de réplication.

- `status`

  Affiche le message de statut court du serveur.

- `slave-stop`

  Eteind l'esclave de réplication.

- `variables`

  Affiche les variable disponibles.

- `version`

  Affiche la version du serveur.

Toutes les commandes peuvent être réduites à leur préfixe simple. Par exemple :

    shell> mysqladmin proc stat
    +----+-------+-----------+----+-------------+------+-------+------+
    | Id | User  | Host      | db | Command     | Time | State | Info |
    +----+-------+-----------+----+-------------+------+-------+------+
    | 6  | monty | localhost |    | Processlist | 0    |       |      |
    +----+-------+-----------+----+-------------+------+-------+------+
    Uptime: 10077  Threads: 1  Questions: 9  Slow queries: 0
    Opens: 6 Flush tables: 1  Open tables: 2
    Memory in use: 1092K  Max memory used: 1116K

La commande `mysqladmin status` liste les colonnes suivantes :

- `Uptime`

  Nombre de secondes de vie du serveur MySQL.

- `Threads`

  Nombre de threads actifs (clients).

- `Questions`

  Nombre de questions re¸u des clients depuis le démarrage de `mysqld`.

- `Slow queries`

  Nombre de requêtes qui ont pris plus de `long_query_time` secondse. See Section 5.9.5, « Le log des requêtes lentes ».

- `Opens`

  Combien de tables sont ouvertes par `mysqld`.

- `Flush tables`

  Nombre de commandes `flush ...`, `refresh` et `reload`.

- `Open tables`

  Nombre de tables qui sont ouvertes actuellement.

- `Memory in use`

  Mémoire allouée directement par `mysqld` (uniquement disponible si MySQL a été compilé avec l'option --with-debug=full).

- `Maximum memory used`

  Maximum de mémoire allouée directement par `mysqld` (uniquement disponible si MySQL a été compilé avec l'option `--with-debug=full`).

Si vous exécutez `mysqladmin shutdown` en vous connectant à un serveur local, avec un fichier de socket Unix, `mysqladmin` va attendre que le fichier de processus du serveur soit supprimé, pour s'assurer que le serveur est bien arrété.

`mysqladmin` supporte les options suivantes :

- `--help, -?`

  Affiche le message d'aide et quitte.

- `--character-sets-dir=path`

  Le dossier où les jeux de caractères sont stockés. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--compress, -C`

  Compresse toutes les informations entre le client et le serveur, si les deux le supporte.

- `--count=#, -c #`

  Le nombre d'itération à faier. Cela fonctionne uniquement avec `--sleep` (`-i`).

- `--debug[=debug_options], -# [debug_options]`

  Écrit un log de débogage. La chaîne `debug_options` est souvent `'d:t:o,file_name'`. La valeur par défaut est `'d:t:o,/tmp/mysqladmin.trace'`.

- `--force, -f`

  Ne demande pas de confirmation pour la commande `drop database`. Avec des commandes multiples, continue même si une erreur survient.

- `--host=host_name, -h host_name`

  Connexion au serveur MYSQL avec le nom d'hôte donné.

- `--password[=password], -p[password]`

  Le mot de passe utilisé lors de la connexion sur le serveur. S'il n'est pas donné en ligne de commande, il sera demandé interactivement. Notez que si vous utilisez la forme courte `-p`, vous ne devez pas laisser d'espace entre l'option et le mot de passe.

- `--port=port_num, -P port_num`

  Le numéro de port TCP/IP pour la connexion.

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Spécifie le protocole de connexion à utiliser. Nouveau en MySQL 4.1.

- `--relative, -r`

  Affiche la différence entre la valeur courante et la valeur précédente, lorsqu'utilisé avec l'option `-i`. Actuellement, cette option fonctionne avec la commande `extended-status`.

- `--silent, -s`

  Mode très silencieux.

- `--sleep=delay, -i delay`

  Exécute les commandes encore et encore, avec `delay` secondes entre deux.

- `--socket=path, -S path`

  Le fichier de socket à utiliser pour la connexion.

- `--user=user_name, -u user_name`

  Nom d'utilisateur pour la connexion, si ce n'est pas l'utilisateur Unix courant.

- `--verbose, -v`

  Affichage plus détaillé (-v -v -v indique le format d'affichage de table).

- `--version, -V`

  Affiche la version et quitte.

- `--vertical, -E`

  Print output vertically. This is similar to `--relative`, but prints output vertically.

- `--wait[=#], -w[#]`

  Si la connexion n'a pu être établie, attent et ressaie au lieu d'abandonner. Si une valeur est spécifiée, elle indique le nombre de tentatives. La valeur par défaut est 1 fois.

Vous pouvez aussi configurer ces options avec la syntaxe `--var_name=value` :

- `connect_timeout`

  Le nombre de secondes avant une éxpiration de connexion. (Par défaut, 0.)

- `shutdown_timeout`

  Le nombre de seconde d'attente de l'extinction. (Par défaut, 0.)

Il est aussi possible de configurer les variables en utilisant `--set-variable=var_name=value` ou la syntaxe `-O var_name=value`. Cependant, cette syntaxe est obsolète depuis MySQL 4.0.

## 8.5. `mysqlbinlog`, Exécuter des requêtes dans le log binaire

Les fichiers de log sont écrits dans un format binaire. Vous pouvez éxaminer le log binaire avec l'utilitaire `mysqlbinlog`. Il est disponible depuis MySQL 3.23.14.

Appelez `mysqlbinlog` comme ceci :

    shell> mysqlbinlog [options] log-file ...

Par exemple, pour afficher le contenu du fichier de log binaire `binlog.000003`, utilisez cette commande :

    shell> mysqlbinlog binlog.0000003

Le résultat est toutes les requêtes contenues dans le fichier de log binaire `binlog.000003`, avec différentes informations (durée de la requête, identifiant du thread qui l'a émise, timestamp d'émission, etc.).

Normalement, vous utilisez `mysqlbinlog` pour lire les fichiers de log directement, et les envoyer au serveur MySQL local. Il est aussi possible de lire le fichier binaire sur un serveur distant en utilisant l'option `--read-from-remote-server`. Cependant, c'est une technique abandonnée, car nous préférons rendre plus simple l'utilisation des logs binaires sur un serveur MySQL local.

Lorsque vous lisez des logs binaires distants, les options de connexion peuvent être données pour indiquer comment se connecter au serveur, mais ils sont ignorés à moins que vous ne spécifiez aussi l'option `--read-from-remote-server`. Ces options sont `--host`, `--password`, `--port`, `--protocol`, `--socket` et `--user`.

Vous pouvez aussi utiliser `mysqlbinlog` pour relayer des fichiers de log écrits par un serveur esclave, dans une architecture de réplication. Les logs de relais sont au même format que le log binaire.

Le log binaire est présenté en détails dans la section Section 5.9.4, « Le log binaire ».

`mysqlbinlog` supporte les optiosn suivantes :

- `--help, -?`

  Affiche cette aide et quitte.

- `--database=db_name, -d db_name`

  Limite les lignes à cette base de données (log local uniquement).

- `--force-read, -f`

  Continue même si vous obtenez une erreur SQL.

- `--host=host_name, -h host_name`

  Lit le log binaire depuis le serveur MySQL distant.

- `--local-load=path, -l path`

  Prépare les fichiers temporaires destinés aux commandes `LOAD DATA INFILE` dans le dossier spécifié.

- `--offset=N, -o N`

  Ignore les `N` première lignes.

- `--password[=password], -p[password]`

  Le mot de passe utilisé lors de la connexion sur le serveur. S'il n'est pas donné en ligne de commande, il sera demandé interactivement. Notez que si vous utilisez la forme courte `-p`, vous ne devez pas laisser d'espace entre l'option et le mot de passe.

- `--port=port_num, -P port_num`

  Le numéro de port TCP/IP pour la connexion.

- `--position=N, -j N`

  Comment la lecture dans le log binaire à la position `N`.

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Spécifie le protocole de connexion à utiliser. Nouveau en MySQL version 4.1.

- `--read-from-remote-server, -R`

  Read the binary log from a MySQL server. Les options de connexion distantes seront ignorées à moins que cette option ne soit donné. Ces options sont `--host`, `--password`, `--port`, `--protocol`, `--socket` et `--user`.

- `--result-file=name, -r name`

  Export direct vers le fichier spécifié.

- `--short-form, -s`

  Affiche uniquement les commandes du log, sans les informations supplémentaires.

- `--socket=path, -S path`

  Le fichier de socket à utiliser pour la connexion.

- `--user=user_name, -u user_name`

  Le nom d'utilisateur MySQL lors de la connexion à distance.

- `--version, -V`

  Affiche la version et quitte.

Vous pouvez aussi configurer les variables suivantes avec l'option `--var_name=value` :

- `open_files_limit`

  Spécifie le nombre de pointeurs de fichiers à réserver.

Vous pouvez envoyer le résultat de `mysqlbinlog` vers un client `mysql` avec un pipe : c'est une technique pour restaurer le serveur après un crash (see Section 5.7.1, « Sauvegardes de base de données ») :

    shell> mysqlbinlog hostname-bin.000001 | mysql

ou :

    shell> mysqlbinlog hostname-bin.[0-9]* | mysql

Vous pouvez aussi rediriger le résultat de `mysqlbinlog` dans un fichier texte, modifier ce fichier (supprimer les requêtes qui vous gênent), puis exécuter ces requêtes, depuis le fichier, avec `mysql`. Après edition du fichier, exécutez les commandes qu'il contient comme d'habitude, avec le programme `mysql`.

`mysqlbinlog` dispose de l'option `--position` qui affiche les requêtes du log binaire à partir de la position spécifiée.

Si vous avez plus d'un fichier de log binaire à exécuter sur le serveur MySQL, la méthode sûre est de tout faire avec la même connexion MySQL. Voici la méthode dangeureuse :

    shell> mysqlbinlog hostname-bin.000001 | mysql # DANGER!!
    shell> mysqlbinlog hostname-bin.000002 | mysql # DANGER!!

Cela va causer des problèmes si le premier log contient des commandes de type `CREATE TEMPORARY TABLE` et que le second contient des requêtes d'utilisation de cette table : lorsque le premier `mysql` termine son exécution, il va détruire la table, et le second va rencontrer des erreurs ``unknown table''.

Pour éviter cela, utilisez une seule connexion, surtout si vous utilisez des tables temporaires. Voici deux méthodes possibles :

    shell> mysqlbinlog hostname-bin.000001 hostname-bin.000002 | mysql

La seconde méthode :

    shell> mysqlbinlog hostname-bin.000001 >  /tmp/statements.sql
    shell> mysqlbinlog hostname-bin.000002 >> /tmp/statements.sql
    shell> mysql -e "source /tmp/statements.sql"

Depuis MySQL 4.0.14, `mysqlbinlog` peut préparer des requêtes valides pour `mysql`, afin d'il utilise la commande `LOAD DATA INFILE` depuis le log binaire. COmme le log contient les données à charger (c'est vrai depuis MySQL 4.0; MySQL 3.23 n'inscrivait pas les données à charger dans le log binaire, et le fichier original était nécessaire pour éxécuter le contenu du log binaire), `mysqlbinlog` va copier ces données dans un fichie temporaire et émettre une commande `LOAD DATA INFILE` pour que `mysql` le charge. Le dossier du fichier temporaire est le dossier temporaire par défaut : il peut être modifié avec l'option `local-load` de `mysqlbinlog`.

Comme `mysqlbinlog` convertit les commandes `LOAD DATA INFILE` en commandes `LOAD DATA LOCAL INFILE` (c'est à dire qu'il ajoute`LOCAL`), le client et le serveur que vous utilisez pour traiter les commandes doivent être configuré pour autoriser l'option `LOCAL`. See Section 5.4.4, « Problèmes de sécurité avec LOAD DATA LOCAL ».

ATTENTION : lorsque vous exécutez `mysqlbinlog` sur un fichier binaire, il va créer un fichier temporaire pour chaque commande `LOAD DATA INFILE`. Ces fichiers ne seront pas automatiquement effacés, car vous en aurez besoin lorsque vous exécuterez les commandes SQL générées. Il faudra les effacer manuellement lorsque vous n'en aurez plus besoin. Les fichiers portent le nom de `temporary-dir/original_file_name-#-#`.

Dans le futur, nous allons corriger ce problème, en permettant à `mysqlbinlog` de se connecter directement au serveur `mysqld`. Dans ce cas, nous pourrons supprimer tranquillement les fichiers de log, lorsqu'ils auront été utilisés.

Avant MySQL 4.1, `mysqlbinlog` ne pouvait pas préparer de log SQL pour `mysql` lorsque le log binaire contenait des requêtes de différents threads, utilisant des tables temporaires de même nom, si les requêtes étaient mélangées. Ceci est corrigé en MySQL 4.1.

## 8.6. `mysqlcc`, MySQL Control Center

`mysqlcc`, MySQL Control Center, est un client portable qui fournit une interface graphique (GUI) au serveur MySQL. Il supporte l'utilisation interactive, y compris la coloration syntaxique et la complétion. Il permet de gérer les tables et bases, et d'administrer le serveur.

Actuellement, `mysqlcc` fonctionne sur Windows et Linux.

`mysqlcc` n'est pas inclus avec les distribution MySQL, mais il peut être téléchargé séparément à http://dev.mysql.com/downloads/. Actuellement, `mysqlcc` fonctionne sur Windows et Linux.

Lancez `mysqlcc` en double-cliquant sur son icone en environnement graphique. En ligne de commande, utilisez ceci :

    shell> mysqlcc [options]

`mysqlcc` supports the following options:

- `--help, -?`

  Affiche cette aide.

- `--blocking_queries, -b`

  Utilise les requêtes bloquantes.

- `--compress, -C`

  Utilise la compression avec le protocole client/serveur.

- `--connection_name=name, -c name`

  Synonyme de `--server`.

- `--database=db_name, -d db_name`

  Base de données à utiliser. C'est généralement utile dans un fichier d'options.

- `--history_size=#, -H #`

  Taille de l'historique de la fenêtre de requête.

- `--host=host_name, -h host_name`

  Hôte de connexion.

- `--local-infile[={0|1}]`

  Active ou désactive les fonctionnalités `LOCAL` de `LOAD DATA INFILE`. Sans valeur, cette option active `LOCAL`. `LOCAL` peut être spécifié sous la forme `--local-infile=0` ou `--local-infile=1` pour être désactivée ou activée. Activer `LOCAL` n'a pas d'effet si le serveur ne le supporte pas.

- `--password[=password], -p[password]`

  Le mot de passe lors de la connexion au serveur. Si le mot de passe n'est pas donné en ligne de commande, il vous sera demandé. Notez que si vous utilisez la forme courte `-p`, vous ne devez pas mettre d'espace entre l'option et le mot de passe.

- `--plugins_path=name, -g name`

  Chemin du dossier de module de MySQL Control Center.

- `--port=port_num, -P port_num`

  Numéro de port TCP/IP pour la connexion.

- `--query, -q`

  Ouvre une fenêtre de requête au démarrage.

- `--register, -r`

  Ouvre la fenêtre de dialogue 'Register Server'.

- `--server=name, -s name`

  Nom de la connexion de MySQL Control Center.

- `--socket=path, -S path`

  Fichier de socket à utiliser pour la connexion.

- `-y, --syntax`

  Active la coloration syntaxique et la complétion.

- `--syntax_file=name, -Y name`

  Fichier de syntaxe pour la complétion.

- `--translations_path=name, -T name`

  Chemin jusqu'au dossier de traductions de MySQL Control Center.

- `--user=user_name, -u user_name`

  Nom d'utilisateur.

- `--version, -V`

  Affiche la version.

Vous pouvez spécifier les variables suivantes avec l'option `-O` ou `--set-variable`.

- `connect_timeout`

  Nombre de seconde avant que la connexion expire. (Valeur par défaut 0)

- `max_allowed_packet`

  Taille maximale des paquets à échanger avec le serveur (Valeur par défaut 16777216)

- `max_join_size`

  Limite automatique du nombre de lignes dans une jointure avec l'option `--safe-updates` (Valeur par défaut 1000000)

- `net_buffer_length`

  Buffer de communication TCP/IP (Valeur par défaut 16384)

- `select_limit`

  Limite automatique pour les commandes `SELECT` avec l'option `--safe-updates` (Valeur par défaut 1000)

Notez que les syntaxes `--set-variable=name=value` et `-O name=value` sont obsolètes depuis MySQL 4.0. Utilisez `--name=value`.

## 8.7. Utiliser `mysqlcheck` pour l'entretien et la réparation

Vous pouvez utiliser `mysqlcheck` comme outil d'entretien et de réparation pour les tables `MyISAM`. `mysqlcheck` est disponible depuis MySQL version 3.23.38.

`mysqlcheck` est similaire à `myisamchk` mais il fonctionne différemment. `mysqlcheck` doit être utilisé lorsque le serveur `mysqld` fonctionne, alors que `myisamchk` doit être utilisé lorsque le serveur ne fonctionne pas. L'intérêt st que vous n'avez plus besoin d'interrompre le serveur pour vérifier ou réparer vos tables.

`mysqlcheck` utilise les commandes du serveur MySQL `CHECK`, `REPAIR`, `ANALYZE` et `OPTIMIZE`, d'une manière pratique pour l'utilisateur.

Il y a trois fa¸ons différentes d'utiliser `mysqlcheck` :

    shell> mysqlcheck [options] db_name [tables]
    shell> mysqlcheck [options] --databases DB1 [DB2 DB3...]
    shell> mysqlcheck [options] --all-databases

Il peut aussi être utilisé comme `mysqldump` lorsqu'il faut choisir les bases et tables à traiter.

`mysqlcheck` dispose d'une fonctionnalité spéciale, comparé aux autres clients : le comportement par défaut, c'est à dire la vérification des tables, peut être modifiée en renommant le fichier binaire. Si vous voulez avoir un fichier qui réparer les tables par défaut, il suffit de copier `mysqlcheck` sur votre disque, et de l'appeler `mysqlrepair`, ou bien, de faire un lien symbolique sur l'exécutable et de l'appeler `mysqlrepair`. Si vous appelez `mysqlrepair`, il va réparer les tables par défaut.

Les noms que vous pouvez utiliser pour que `mysqlcheck` réparer automatiquement les tables sont :

`mysqlrepair` | L'option par défaut est `--repair`
`mysqlanalyze` | L'option par défaut est `--analyze`
`mysqloptimize` | L'option par défaut est `--optimize`

Les options disponibles pour `mysqlcheck` sont listées ici. Vérifiez que votre version les supporte avec la commande `mysqlcheck --help`.

- `-?, --help`

  Affiche ce message d'aide, et termine.

- `--all-databases, -A`

  Vérifie toutes les bases. C'est la même chose que `--databases` dans toutes les bases sélectionnées.

- `--all-in-1, -1`

  Au lieu de faire une requête par table, exécute toutes les requêtes dans une requête, séparément pour chaque base. Les noms de tables seront séparés par une virgule.

- `--analyze, -a`

  Analyse les tables indiquées.

- `--auto-repair`

  Si une table vérifiées est corrompue, la corrige automatiquement. La réparation sera faite après la vérification de toutes les tables, si des tables corrompues ont été découvertes.

- `--character-sets-dir=...`

  Dossier contenant le jeu de caractères. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--check, -c`

  Vérifie les tables en erreur

- `--check-only-changed, -C`

  Vérifie uniquement les tables qui ont été modifiées depuis la dernière modification, ou qui n'ont pas été correctement fermées.

- `--compress`

  Utiliser la compression du protocole client/serveur.

- `--databases, -B`

  Pour tester plusieurs bases de données. Notez que la différence d'utilisation : dans ce cas, aucune table n'est précisé. Tous les arguments de noms sont considérés comme des noms de base.

- `--debug[=debug_options], -# [debug_options]`

  Affiche le log de débogage. Souvent, la chaîne `debug_options` vaut `'d:t:o,nom_de_fichier'`.

- `--default-character-set=...`

  Spécifie le jeu de caractères par défaut. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--extended, -e`

  Si vous utilisez cette option avec `CHECK TABLE`, elle va s'assurer que la table est totalement cohérente, mais prendre un très long temps.

  Si vous utilisez cette option avec REPAIR TABLE, elle va réaliser une réparation exhaustive de la table, qui peut non seulement prendre un temps très long, mais produire de nombreuses lignes erronées.

- `--fast, -F`

  Ne vérifie que les tables qui n'ont pas été correctement fermées.

- `--force, -f`

  Continue même si on rencontre une erreur SQL.

- `--host=host_name, -h host_name`

  Connexion à l'hôte.

- `--medium-check, -m`

  Plus rapide que la vérification complète, mais ne trouvera que 99.99 % de toutes les erreurs. Cela devrait être la bonne option pour la plupart des situations.

- `--optimize, -o`

  Optimise la table.

- `--password[=password], -p[password]`

  Le mot de passe à utiliser lors de la connexion au serveur. Si aucun mot de passe n'est fourni, il sera demandé en ligne de commande. Il ne faut pas laisser d'espace entre l'option -p et le mot de passe.

- `--port=port_num, -P port_num`

  Le numéro de port de la connexion.

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Pour spécifier le protocole à utiliser pour la connexion. Nouveau en MySQL 4.1.

- `--quick, -q`

  Si vous utilisez cette option avec `CHECK TABLE`, elle va éviter que l'analyse ne traite toutes les lignes pour vérifier les mauvais liens. C'est la méthode d'analyse la plus rapide.

  Si vous utilisez cette option avec REPAIR TABLE, elle va essayer de ne réparer que le fichier d'index. C'est la méthode la plus rapide pour la réparation.

- `--repair, -r`

  Peut corriger presque tout, sauf les problèmes de doublons pour les clés uniques.

- `--silent, -s`

  Affiche moins de messages d'erreurs.

- `--socket=path, -S path`

  Nom du fichier de socket à utiliser pour la connexion.

- `--tables`

  Remplace l'option `--databases` ou `-B`. Tous les arguments suivants sont considérés comme des noms de tables.

- `--user=user_name, -u user_name`

  Nom d'utilisateur pour la connexion, si ce n'est pas l'utilisateur courant.

- `--verbose, -v`

  Afficher des informations sur les différentes étapes.

- `--version, -V`

  Affiche les informations de version, et termine.

## 8.8. `mysqldump`, sauvegarde des structures de tables et les données

Utilitaire qui permet d'exporter une base ou un groupe de bases vers un fichier texte, pour la sauvegarde ou le transfert entre deux serveurs (pas nécessairement entre serveurs MySQL). L'export contiendra les requêtes SQL nécessaires pour créer la table et la remplir.

Si vous faîtes une sauvegarde du serveur, vous devriez aussi utiliser la commande `mysqlhotcopy`. See Section 8.9, « `mysqlhotcopy`, copier les bases et tables MySQL ».

Il y a plusieurs méthodes pour invoquer `mysqldump` :

    shell> mysqldump [options] db_name [tables]
    shell> mysqldump [options] --databases DB1 [DB2 DB3...]
    shell> mysqldump [options] --all-databases

Si vous ne spécifiez pas de table, ou si vous utilisez l'option `--databases` ou `--all-databases`, la base de données complète sera exportée.

Vous pouvez obtenir une liste des options valides pour votre version de `mysqldump` avec la commande `mysqldump --help`.

Notez que si vous exécutez `mysqldump` sans l'option `--quick` ou `--opt`, `mysqldump` va charger la totalité du résultat en mémoire, avant de l'écrire. Cette option peut résoudre des problèmes de mémoire si vous exportez de grosses tables.

Notez que si vous utilisez une nouvelles copie du programme `mysqldump`, et que vous allez faire un export qui sera lu dans une vieille version de MySQL, vous ne devriez pas utiliser les options `--opt` et `-e`.

Les valeurs numériques hors des plages de validité comme `-inf` et `inf`, ainsi que `NaN` (`not-a-number`, pas un nombre) sont exportées par `mysqldump` comme `NULL`. Vous pouvez le voir dans la table suivante :

    mysql> CREATE TABLE t (f DOUBLE);
    mysql> INSERT INTO t VALUES(1e+111111111111111111111);
    mysql> INSERT INTO t VALUES(-1e111111111111111111111);
    mysql> SELECT f FROM t;
    +------+
    | f    |
    +------+
    |  inf |
    | -inf |
    +------+

Pour cette table, `mysqldump` produit l'export suivant :

    --
    -- Dumping data for table `t`
    --

    INSERT INTO t VALUES (NULL);
    INSERT INTO t VALUES (NULL);

La signification de ce comportement est que si vous voulez exporter puis restaurer une table, le nouveau contenu sera peut être différent de l'original. Notez que depuis MySQL 4.1.2 vous ne pouvez pas insérer la valeur `inf` dans la table, et ce comportement de `mysqldump` ne sera pertinent qu'avec les anciens serveurs.

`mysqldump` supporte les options suivantes :

- `--help, -?`

  Affiche le message d'aide et quitte.

- `--add-drop-table`

  Ajoute une commande `drop table` avant chaque requête de création de table.

- `--add-locks`

  Ajoute une commande `LOCK TABLES` avant l'export de table et une commande `UNLOCK TABLE` après(Pour accélérer les insertions dans MySQL). See Section 7.2.14, « Vitesse des requêtes `INSERT` ».

- `--all-databases, -A`

  Exporte toutes les tables. C'est l'équivalent de l'option `--databases` avec toutes les bases de données sélectionnées.

- `--allow-keywords`

  Permet la création de colonnes ayant des noms de mots réservés. Cela fonctionne en préfixant chaque nom de colonne avec le nom de la table.

- `--comments[={0|1}]`

  Si cette option prend `0`, elle supprime les informations additionnelles (comme les versions de programme, les versions d'hôte) dans les exports. L'option `--skip-comments` fait la même chose. Par défaut, la valeur de cette option est `1`, pour conserver ces informations. Nouveau en MySQL 4.0.17.

- `--compatible=name`

  Produit un résultat qui est compatible avec les autres bases de données, ou avec d'anciennes versions de MySQL. Les valeurs possibles de `name` sont `mysql323`, `mysql40`, `postgresql`, `oracle`, `mssql`, `db2`, `sapdb`, `no_key_options`, `no_table_options`, ou `no_field_options`. Pour utiliser plusieurs valeurs, séparez les par des virgules. Ces valeurs ont la même signification que les options correspondantes de configuration du mode SQL. See Section 5.2.2, « Le mode SQL du serveur ».

  Cette option requiert la version 4.1.0 ou plus récente. Avec les anciens serveurs, cela ne fait rien.

- `--complete-insert, -c`

  Utilise des commandes `INSERT` complètes, avec les noms de colonnes.

- `-C, --compress`

  Compresse toutes les informations entre le client et le serveur, les deux supporte la compression.

- `--create-options`

  Inclut toutes les options spécifiques MySQL de création de table dans les commandes `CREATE TABLE`. Avant MySQL 4.1.2, utilisez `--all`.

- `--databases, -B`

  Pour exporter plusieurs bases de données. Notez la différence d'utilisation. Dans ce cas, aucune table n'est spécifié. Tous les arguments de noms sont considérés comme des noms de base. Une ligne `USE db_name;` sera ajoutée dans l'export avant chaque base de données.

- `--debug[=debug_options], -# [debug_options]`

  Active l'historique de débogage. La chaîne de format est généralement `'d:t:o,file_name'`.

- `--default-character-set=charset`

  Configure le jeu de caractères par défaut pour l'export. S'il n'est pas spécifié, `mysqldump` 10.3 (MySQL-4.1.2) ou plus récent va utiliser `utf8`. Les versions plus anciennes utiliseront `latin1`.

- `--delayed`

  Les insertions se font avec la commande `INSERT DELAYED`.

- `--delete-master-logs`

  Sur un maître de réplication, efface le log binaire une fois que l'opération d'export est faite. Cette option active automatiquement `--first-slave`. Elle a été ajoutée en MySQL 3.23.57 (pour MySQL 3.23) et MySQL 4.0.13 (pour MySQL 4.0).

- `--disable-keys, -K`

  Pour chaque table, entoure les commandes d'`INSERT` avec les commandes `/*!40000 ALTER TABLE tbl_name DISABLE KEYS */;` et `/*!40000 ALTER TABLE tbl_name ENABLE KEYS */;`. Cela accélère les chargements du fichier d'export pour MySQL 4.0 car les index ne sont créés qu'après l'insertion. Cette option n'est effective que pour les tables `MyISAM`.

- `--extended-insert, -e`

  Utilise la nouvelle syntaxe multi-ligne `INSERT`. (Cela donne des insertions plus courtes et plus efficaces).

- `--fields-terminated-by=...`, `--fields-enclosed-by=...`, `--fields-optionally-enclosed-by=...`, `--fields-escaped-by=...`, `--lines-terminated-by=...`

  Ces options sont utilisées avec l'option `-T` et ont la même signification que les clauses correspondantes de la commande `LOAD DATA INFILE`. See Section 13.1.5, « Syntaxe de `LOAD DATA INFILE` ».

- `--first-slave, -x`

  Verrouille toutes les tables de toutes les bases de données.

- `--flush-logs, -F`

  Ecrit tout le fichier de log du serveur avant de commencer l'export. Notez que si vous utilisez cette option avec `--all-databases` (ou l'option `-A`), les logs seront vidés pour chaque base de données exportée.

- `-f, --force,`

  Continue même si une erreur SQL survient durant l'export.

- `--host=host_name, -h host_name`

  Exporte les données depuis le serveur MySQL vers l'hôte indiqué. L'hôte par défaut est `localhost`.

- `--lock-tables, -l`

  Verrouille toutes les tables avant de commencer l'export. Les tables sont verrouillées avec `READ LOCAL` pour permettre des insertions concurrentes sur les tables `MyISAM`.

  Notez que lorsque vous exportes des tables de bases différentes, l'option `--lock-tables` va verrouiller chaque base séparément. Cette option ne vous garantira pas que vos tables seront logiquement cohérente entre les bases. Des tables de différentes bases pourraient être exportées dans des états très différents.

- `--master-data`

  Cette option est similaire à `--first-slave`, mais produit aussi une commande `CHANGE MASTER TO` qui fait que le serveur esclave va commencer à la bonne position dans le log du maître, si vous utilisez cette exportation pour configurer initialement l'esclave.

- `--no-create-db, -n`

  `CREATE DATABASE /*!32312 IF NOT EXISTS*/ db_name;` ne sera pas ajouté dans l'export. Sinon, la ligne ci-dessus sera ajoutée, si l'une des options `--databases` ou `--all-databases` ont été activée.

- `--no-create-info, -t`

  N'écrit pas les informations de création de table (la requête `CREATE TABLE`).

- `--no-data, -d`

  N'écrit aucune ligne d'informations sur la table. C'est très pratique si vous voulez simplement exporter la structure de la table.

- `--opt`

  Identique à `--quick --add-drop-table --add-locks --extended-insert --lock-tables`. Vous obtiendrez l'export le plus rapide à importer dans un serveur MySQL.

- `--password[=password], -p[password]`

  Le mot de passe à utiliser lors de la connexion au serveur. Notez que si vous utilisez l'option courte `-p`, vous ne devez pas laisser d'espace entre l'option et le mot de passe. Si vous spécifiez en omettant la partie ‘`=your_pass`’, `mysqldump` vous demandera le mot de passe en ligne de commande.

- `--port=port_num, -P port_num`

  Le port TCP/IP à utiliser avec l'hôte.

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Pour spécifier le protocole de connexion à utiliser. Nouveau en MySQL 4.1.

- `--quick, -q`

  Ne garde pas en buffer les requêtes, mais écrit immédiatement dans la sortie. Utilise `mysql_use_result()` pour cela.

- `--quote-names, -Q`

  Protège les noms des tables et colonnes avec le caractère ‘```’.

- `--result-file=file, -r file`

  Ecrit directement dans le fichier indiqué. Cette option doit être utilisé sur MSDOS, car cela évite que la nouvelle ligne ‘`\n`’ soient converties en ‘`\n\r`’ (nouvelle ligne et retour chariot).

- `--single-transaction`

  Cette option ajoute la commande SQL `BEGIN` avant d'exporter les données vers le serveur. C'est généralement pratique pour les tables `InnoDB` et le niveau d'isolation de transaction `READ_COMMITTED`, car ce mode va exporter l'état de la base au moment de la commande `BEGIN` sans bloquer les autres applications.

  Lorsque vous utilisez cette option, pensez bien que seules les tables transactionnelles seront exportées dans un état cohérent, c'est à dire que les tables `MyISAM` ou `HEAP` qui seront exportées avec cette option, pourront changer d'état.

  L'option `--single-transaction` a été ajoutée en version 4.0.2. Cette option est mutuellement exclusive avec l'option `--lock-tables` car `LOCK TABLES` va valider une transaction interne précédente.

- `--socket=path, -S path`

  Le fichier de socket à utiliser pour les connexions locale (à `localhost`), qui est l'hôte par défaut.

- `--skip-comments`

  Identique à que `--comments` = `0`.

- `--tab=path, -T path`

  Crée un fichier `table_name.sql`, qui contient les commandes SQL `CREATE`, et un fichier `table_name.txt`, qui contient les données, pour chaque table. Le format du fichier `.txt` est celui qui est spécifié par les options `--fields-xxx` et `--lines--xxx`. Note : cette option ne fonctionne qui si `mysqldump` est exécuté sur la même machine que le démon `mysqld`, et que le nom d'utilisateur et le groupe de `mysqld` (normalement l'utilisateur `mysql`, et le groupe `mysql`) doivent avoir des permission pour créer et écrire un fichier dans le dossier que vous spécifiez.

- `--tables`

  Remplace l'option `--databases` ou `-B`. Tous les arguments suivant les options sont considérés comme des noms de tables.

- `--user=user_name, -u user_name`

  Le nom d'utilisateur MySQL lors de la connexion à un serveur distant.

- `--verbose, -v`

  Mode détaillé. Affiche plus d'informations sur les faits et gestes du programme.

- `--version, -V`

  Affiche la version du programme et quitte.

- `--where='where-condition', -w 'where-condition'`

  Exporte uniquement les lignes sélectionnées. Notez que les guillemets sont obligatoires.

  Exemples :

      "--where=user='jimf'"
      "-wuserid>1"
      "-wuserid<1"

- `-X, --xml`

  Exporte la base au format XML.

Vous pouvez aussi configurer les variables systèmes suivantes avec la syntaxe `--var_name=value` :

- `max_allowed_packet`

  La taille maximale du buffer pour les communications client / serveur. La valeur de cette variable peut être au maximum de 16 Mo avant MySQL 4.0, et jusqu'à 1 Go depuis MySQL 4.0. Lors de la création de commandes d'insertions multiples (avec l'option `--extended-insert` ou `--opt`), `mysqldump` va créer des lignes ayant une taille maximale de `max_allowed_packet` octets. Si vous augmentez la valeur de cette variable, assurez vous que `max_allowed_packet` est assez grande dans le serveur.

- `net_buffer_length`

  La taille initiale du buffer de communication.

Il est aussi possible de configurer les variables en utilisant `--set-variable=var_name=value` ou `-O var_name=value`. Mais cette syntaxe est obsolète depuis MySQL 4.0.

L'usage normal de `mysqldump` est probablement de faire des sauvegardes de bases.

    mysqldump --opt database > backup-file.sql

Vous pouvez importer les données dans la base MySQL avec :

    mysql database < backup-file.sql

ou

    mysql -e "source /patch-to-backup/backup-file.sql" database

Cependant, il est très pratique pour remplir un autre serveur MySQL avec des informations depuis une base :

    mysqldump --opt database | mysql ---host=remote-host -C database

Il est possible d'exporter plusieurs bases de données en une seule commande :

    mysqldump --databases database1 [database2 ...] > my_databases.sql

Si vous souhaitez exporter toutes les bases, vous pouvez utiliser :

    mysqldump --all-databases > all_databases.sql

Pour plus d'informations sur les sauvegardes, voyez Section 5.7.1, « Sauvegardes de base de données ».

## 8.9. `mysqlhotcopy`, copier les bases et tables MySQL

`mysqlhotcopy` est un script Perl qui utilise `LOCK TABLES`, `FLUSH TABLES` et `cp` ou `scp` pour faire rapidement des sauvegardes de bases. C'est la méthode la plus rapide pour faire une sauvegarde. C'est aussi le moyen le plus sûr pour copier des tables et bases, mais il ne peut fonctionner que sur la machine qui contient les fichiers de données. `mysqlhotcopy` fonctionne uniquement sous Unix, et il ne fonctionne qu'avec les tables de type `MyISAM` et `ISAM`.

    shell> mysqlhotcopy db_name [/path/to/new_directory]

    shell> mysqlhotcopy db_name_1 ... db_name_n /path/to/new_directory

    shell> mysqlhotcopy db_name./regex/

`mysqlhotcopy` supporte les options suivantes :

- `-?, --help`

  Affiche un écran d'aide et quitte.

- `--allowold`

  Ne pas annuler si la sauvegarde existe déjà (renomme la simplement en _old)

- `--checkpoint=db_name.tbl_name`

  Insère un point de contrôle dans la table spécifiée (base.table)

- `--debug`

  Active le débogage.

- `--dryrun, -n`

  Rapporte les actions réalisées sans les faire.

- `--flushlog`

  Vide les logs sur le disque une fois que toutes les tables sont verrouillées.

- `--keepold`

  Ne pas effacer une sauvegarde précédente (celle qui a été renommée) lorsque c'est terminé.

- `--method=#`

  Méthode de copie (`cp` ou `scp`).

- `--noindices`

  Ne pas inclure les fichiers d'index complet dans la copie, pour faire des fichiers de sauvegarde plus petit et plus rapide. Les index peuvent toujours être reconstruits plus tard avec `myisamchk -rq.`.

- `-p, --password=#`

  Mot de passe utilisé pour la connexion au serveur.

- `--port=port_num, -P port_num`

  Port utilisé pour la connexion au serveur.

- `--quiet, -q`

  Mode silencieux. N'affiche que les erreurs.

- `--regexp=expr`

  Copie toutes les bases dont le nom vérifie un masque d'expression régulière.

- `--socket=path, -S path`

  Socket utilisée pour la connexion au serveur.

- `--suffix=str`

  Suffixe des noms des bases copiées.

- `--tmpdir=path`

  Dossier temporaire (au lieu de `/tmp`).

- `--user=user_name, -u user_name`

  Nom d'utilisateur pour la connexion au serveur.

Vous pouvez essayer `perldoc mysqlhotcopy` pour avoir plus de documentation sur `mysqlhotcopy`.

`mysqlhotcopy` lit les options du groupe `[client]` et `[mysqlhotcopy]` dans le fichier d'options.

Pour être capable d'exécuter `mysqlhotcopy`, vous avez besoin des droits d'écriture dans le dossier de sauvegarde, et le droit de `SELECT` dans les tables que vous souhaitez copier, ainsi que les droits MySQL de `RELOAD` (pour utiliser la commande `FLUSH TABLES`).

    shell> perldoc mysqlhotcopy

## 8.10. `mysqlimport`, importer des données depuis des fichiers texte

`mysqlimport` fournit une interface en ligne de commande à la commande SQL `LOAD DATA INFILE`. La plupart des options de `mysqlimport` correspondent directement aux mêmes options de `LOAD DATA INFILE`. See Section 13.1.5, « Syntaxe de `LOAD DATA INFILE` ».

`mysqlimport` est appelé comme ceci :

    shell> mysqlimport [options] database textfile1 [textfile2 ...]

Pour chaque fichier texte indiqué dans la ligne de commande, `mysqlimport` supprime toute extension du nom du fichier, et utilise le résultat pour déterminer le nom de la table qui va recevoir le contenu du fichier. Par exemple, pour des fichiers appelés `patient.txt`, `patient.text` et `patient` seront tous importés dans la table `patient`.

`mysqlimport` supporte les options suivantes :

- `--help, -?`

  Affiche le message d'aide et quitte.

- `--columns=column_list, -c column_list`

  Cette option prend une liste de noms de colonnes, séparés par des virgules. Ce champs est utilisé pour créer une commande `LOAD DATA INFILE` correcte, qui sera alors passée à MySQL.

- `--compress, -C`

  Compresse toutes les informations entre le client et le serveur, si c'est possible.

- `--debug[=debug_options], -# [debug_options]`

  Active le débogage. la valeur de `debug_options` est souvent : `'d:t:o,file_name'`.

- `--delete, -D`

  Vide la table avant d'importer le fichier texte.

- `--fields-terminated-by=...`, `--fields-enclosed-by=...`, `--fields-optionally-enclosed-by=...`, `--fields-escaped-by=...`, `--lines-terminated-by=...`

  Ces options ont la même signification que les clauses correspondantes de `LOAD DATA INFILE`. See Section 13.1.5, « Syntaxe de `LOAD DATA INFILE` ».

- `--force, -f`

  Ignore les erreurs. Par exemple, si une table n'existe pas pour un fichier texte, `mysqlimport` va continuer de traiter les autres fichiers. Sans `--force`, `mysqlimport` se termine dès qu'une erreur survient.

- `--host=host_name, -h host_name`

  Importe les données sur le serveur MySQL, avec l'hôte spécifié. La valeur par défaut est `localhost`.

- `--ignore, -i`

  Voir la description de `--replace`.

- `--ignore-lines=n`

  Ignore les `n` premières lignes du fichier de données.

- `--local, -L`

  Lit le fichier d'entrée dans le client. Par défaut, les fichiers textes sont supposés être lus par le serveur, si vous vous connectez à `localhost` (qui l'hôte par défaut).

- `--lock-tables, -l`

  Verrouille toutes les tables en écriture avant de ne traiter les fichiers textes. Cela assure que toutes les tables sont synchronisée sur le serveur.

- `--password[=password], -p[password]`

  Le mot de passe à utiliser lors de la connexion au serveur. Notez que si vous utilisez l'option courte (`-p`), vous ne pouvez pas laisser d'espace entre l'option est le mot de passe. Si vous ne spécifiez pas le mot de passe avec l'option, `mysqlimport` va vous demander le mot de passe en ligne.

- `--port=port_num, -P port_num`

  Le port TCP/IP utilisé avec l'hôte. Cela sert pour les connexions à des hôtes qui ne sont pas `localhost`, pour lequel la socket Unix est utilisée.

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Spécifie le protocole à utiliser pour se connecter. Nouveau en MySQL version 4.1.

- `--replace, -r`

  Les options `--replace` et `--ignore` contrôles la gestion des lignes lues envers les lignes qui existent déjà sur le serveur. Si vous spécifiez l'option `--replace`, les nouvelles lignes remplaceront les lignes existantes. Si vous spécifiez `--ignore`, les lignes qui sont en double dans une table qui dispose d'une colonne de type unique. Si vous ne spécifiez pas ces options, une erreur surviendra lorsqu'une clé en double sera trouvée, et la lecture du reste du fichier sera annulé.

- `--silent, -s`

  Mode silencieux. N'affiche que les erreurs qui surviennent.

- `--socket=path, -S path`

  Le fichier de socket à utiliser lors de la connexion à `localhost` (qui est l'hôte par défaut).

- `--user=user_name, -u user_name`

  Le nom de l'utilisateur MySQL à utiliser lors de la connexion au serveur MySQL. La valeur par défaut est celui de votre utilisateur Unix.

- `--verbose, -v`

  Mode détaillé. Affiche bien plus d'informations sur les actions du programme.

- `--verbose, -v`

  Affiche la version et quitte.

Voici un exemple d'utilisation de `mysqlimport` :

    $ mysql --version
    mysql  Ver 9.33 Distrib 3.22.25, for pc-linux-gnu (i686)
    $ uname -a
    Linux xxx.com 2.2.5-15 #1 Mon Apr 19 22:21:09 EDT 1999 i586 unknown
    $ mysql -e 'CREATE TABLE imptest(id INT, n VARCHAR(30))' test
    $ ed
    a
    100     Max Sydow
    101     Count Dracula
    .
    w imptest.txt
    32
    q
    $ od -c imptest.txt
    0000000   1   0   0  \t   M   a   x       S   y   d   o   w  \n   1   0
    0000020   1  \t   C   o   u   n   t       D   r   a   c   u   l   a  \n
    0000040
    $ mysqlimport --local test imptest.txt
    test.imptest: Records: 2  Deleted: 0  Skipped: 0  Warnings: 0
    $ mysql -e 'SELECT * FROM imptest' test
    +------+---------------+
    | id   | n             |
    +------+---------------+
    |  100 | Max Sydow     |
    |  101 | Count Dracula |
    +------+---------------+

## 8.11. Afficher les bases, tables et colonnes

`mysqlshow` peut être utilisé pour lister les bases qui existent, leurs tables et leurs colonnes.

Avec le programme `mysql` vous pouvez obtenir des informations avec la commande `SHOW`. Les mêmes informations sont disponibles en utilisant ces commandes directement. Par exemple, vous pouvez utiliser le client `mysql`. See Section 13.5.3, « Syntaxe de `SHOW` ».

`mysqlshow` est utilisé comme ceci :

    shell> mysqlshow [OPTIONS] [database [table [column]]]

- Si aucune base n'est indiquée, toutes les bases de données sont listées.

- Si aucune table n'est nommée, toutes les tables de la base sont affichées.

- Si aucune colonne n'est nommée, toutes les colonnees et leur type sont affichés.

Notez que dans les nouvelles versions de MySQL, vous ne verrez que les bases de données, tables et colonnes pour lesquelles vous avez des droits.

Si le dernier argument contient un caractère joker shell ou SQL (‘`*`’, ‘`?`’, ‘`%`’ ou ‘`_`’) alors seules les entités qui valident ce masque sont affichées. Si une base contient des caractères soulignés, ils doivent être protégés avec un anti-slash (certains shell Unix en demande même deux), afin de lister correctement les tables et les colonnes. Les ‘`*`’ et ‘`?`’ sont convertis en joker SQL ‘`%`’ and ‘`_`’. Cela peut causer des confusions lorsque vous essayez d'afficher des colonnes qui contiennent un souligné ‘`_`’, comme c'est le cas avec `mysqlshow` qui ne vous affiche que les colonnes qui vérifient le masque. Ceci est facilement corrigé en ajoutant un caractère ‘`%`’ en plus dans la ligne de commande (comme argument séparé).

`mysqlshow` supporte les options suivantes :

- `--help, -?`

  Affiche cette aide et quitte.

- `--character-sets-dir=path`

  Le dossier où les jeux de caractères sont créés. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--compress, -C`

  Utilise la compression avec le protocole client / serveur.

- `--debug[=debug_options], -# [debug_options]`

  Génère un log de débogage. La chaîne `debug_options` vaut souvent `'d:t:o,file_name'`. Par défaut, la valeur est `'d:t:o,/tmp/mysql.trace'`.

- `--default-character-set=charset`

  Configure le jeu de caractères par défaut. See Section 5.8.1, « Le jeu de caractères utilisé pour les données et le stockage ».

- `--host=host_name, -h host_name`

  Connexion avec l'hôte indiqué.

- `--keys, -k`

  Affiche les index de la table.

- `--password[=password], -p[password]`

  Le mot de passe utilisé lors de la connexion sur le serveur. S'il n'est pas donné en ligne de commande, il sera demandé interactivement. Notez que si vous utilisez la forme courte `-p`, vous ne devez pas laisser d'espace entre l'option et le mot de passe.

- `--port=port_num, -P port_num`

  Le numéro de port TCP/IP pour la connexion.

- `--protocol={TCP | SOCKET | PIPE | MEMORY}`

  Spécifie le protocole de connexion à utiliser. Nouveau en MySQL version 4.1.

- `--socket=path, -S path`

  Le fichier de socket à utiliser pour la connexion.

- `--status, -i`

  Affiche des informations supplémentaires sur chaque table.

- `--user=user_name, -u user_name`

  Nom d'utilisateur pour la connexion, si ce n'est pas l'utilisateur Unix courant.

- `--verbose, -v`

  Affichage plus détaillé (`-v -v -v` indique le format d'affichage de table).

- `--version, -V`

  Affiche la version et quitte.

## 8.12. `perror`, expliquer les codes d'erreurs

Pour la plupart des erreurs système, MySQL va, en plus d'un message interne, aussi afficher un code d'erreur, dans l'un des styles suivants :

    message ... (errno: #)
    message ... (Errcode: #)

Vous pouvez découvrir ce que ce code d'erreur signifie soit en examinant la documentation de votre système, soit en utilisant l'utilitaire `perror`.

`perror` affiche une description pour le code d'erreur, ou, pour une erreur du gestionnaire de tables MyISAM/ISAM.

`perror` est appelé comme ceci :

    shell> perror [options] errorcode ...

Exemple :

    shell> perror 13 64
    Error code  13:  Permission denied
    Error code  64:  Machine is not on the network

Notez que les messages d'erreurs sont dépendants du système. Un message d'erreur peut avoir différentes explications sur différents systèmes.

## 8.13. L'utilitaire de remplacement de chaînes `replace`

L'utilitaire `replace` modifie les chaînes dans des fichiers. Elle utilise une machine à états finis pour rechercher d'abord les plus grandes chaînes. Elle peut être utilisée pour faire des échanges de chaînes, entre les chaînes `a` et `b` de deux fichiers `file1` et `file2`:

    shell> replace a b b a -- file1 file2 ...

Utilisez l'option `--` pour indiquer où la liste de chaînes de remplacement s'arrête, et où commence la liste de fichiers.

Tout fichier nommé en ligne de commande est modifié directement : il est recommandé de faire des sauvegardes de fichiers originaux.

Si aucun fichier n'est nommé en ligne de commande, `replace` lit l'entrée standard, et écrit dans la sortie standard. Dansa ce cas, aucune option `--` n'est nécessaire.

Le programme `replace` sert à `msql2mysql`. See Section 24.1.1, « `msql2mysql`, convertit des programmes mSQL vers MySQL ».

`replace` supporte les options suivantes :

- `-?, -I`

  Affiche le message d'aide et quitte.

- `-# debug_options`

  Écrit un log de débogage. La chaîne `debug_options` vaut souvent `'d:t:o,file_name'`.

- `-s`

  Mode silencieux. Affiche moins d'informations sur les activités du programme.

- `-v`

  Mode prolifique. Affiche plus d'informations sur les activités du programme.

- `-V`

  Affiche la version, et quitte.

This is a translation of the MySQL Reference Manual that can be found at dev.mysql.com. The original Reference Manual is in English, and this translation is not necessarily as up to date as the English version.

Précédent |  | Suivant
Chapitre 7. Optimisation de MySQL | Sommaire | Chapitre 9. Structure du langage