Apparence
Uubu.fr

Les systèmes Linux, l’open source, les réseaux, l’interopérabilité, etc.
« Il vaut mieux viser la perfection et la manquer que viser l’imperfection et l’atteindre. » (Bertrand Arthur William RUSSEL)
04 mai 2010

htmlpdflatexmanmd




my.cnf

my.cnf

Fichier de configuration MySQL

   Les programmes suivantes supportent les fichiers d'options : myisamchk, myisampack, mysql, mysql.server, mysqladmin, mysqlbinlog, mysqlcc, mysqlcheck, mysqld_safe, mysqldump, mysqld, mysqlhotcopy, mysqlimport et mysqlshow.

  MySQL lit les fichiers suivant:

/etc/my.cnf options globales
DATADIR/my.cnf Options spécifiques au serveur généralement /usr/local/mysql/data ou /usr/local/var pour une installation source
default-extra-file le fichier spécifié par --default-extra-file=#
/.my.cnf options spécifique à l'utilisateur

   MySQL essaie de lire les fichiers d'options dans l'ordre ci-dessus. La syntaxe dans les fichiers d'options est similaire aux options de la commande, sans les doubles tirets.

#comment ou ;comment Commentaires
[group] group est le nom du programme ou du groupe pour lequel vous souhaitez configurer des options.
opt_name est équivalent à --opt_name sur la ligne de commande
opt_name=value est équivalent à --opt_name=value sur la ligne de commande
set_variable = variable=value est équivalent à --set-variable variable=value, utilisé pour spécifier une variable à mysqld.
On peut utiliser les séquences spéciales ‘\b’, ‘\t’, ‘\n’, ‘\r’, ‘\\’ et ‘\s’ dans les valeurs des options pour représenter des effacement, tabulations, nouvelles lignes, retour chariot et espaces. [client]
le group d'options [client] est lu par tous les programmes clients

Exemple

exemple de fichier d'options global typique
[client]
port=3306
socket=/tmp/mysql.sock

[mysqld]
port=3306
socket=/tmp/mysql.sock
key_buffer_size=16M
max_allowed_packet=8M

[mysqldump]
quick

exemple de fichier d'options utilisateur classique
[client]
# Le mot de passe suivant sera envoyé par tous les clients standards MySQL
password="my_password"

[mysql]
no-auto-rehash
set-variable = connect_timeout=2

[mysqlhotcopy]
interactive-timeout

Options communes à tous les programmes

--no-defaults N'utilise aucun fichier d'options.
--print-defaults Affiche le nom du programme et toutes les options qui seront lues dans les fichiers d'options.
--defaults-file=path_name Utilise uniquement le fichier d'options indiqué. path_name est le chemin complet pour y accéder.
--defaults-extra-file=path_name Lit ce fichier d'options après le fichier d'options globales, et avant le fichier d'options utilisateurs. path_name est le chemin complet pour y accéder.

On peut utiliser my_print_defaults pour analyser les fichiers d'options. il prend en argument les groupes à tester. Exemple:
my_print_defaults client mysql
--port=3306
--socket=/tmp/mysql.sock
--no-auto-rehash

mysql_multi

exemple de fichier d'options pour mysqld-multi:
[mysqld_multi]
mysqld = /usr/local/bin/safe_mysqld
mysqladmin = /usr/local/bin/mysqladmin
user = multi_admin
password = multipass

[mysqld2]
socket = /tmp/mysql.sock2
port = 3307
pid-file = /usr/local/mysql/var2/hostname.pid2
datadir = /usr/local/mysql/var2
language = /usr/local/share/mysql/english
user = john

[mysqld3]
socket = /tmp/mysql.sock3
port = 3308
pid-file = /usr/local/mysql/var3/hostname.pid3
datadir = /usr/local/mysql/var3
language = /usr/local/share/mysql/swedish
user = monty

[mysqld4]
socket = /tmp/mysql.sock4
port = 3309
pid-file = /usr/local/mysql/var4/hostname.pid4
datadir = /usr/local/mysql/var4
language = /usr/local/share/mysql/estonia
user = tonu

[mysqld6]
socket = /tmp/mysql.sock6
port = 3311
pid-file = /usr/local/mysql/var6/hostname.pid6
datadir = /usr/local/mysql/var6
language = /usr/local/share/mysql/japanese
user = jani

^
08 mai 2010

htmlpdflatexmanmd




myisamchk

myisamchk

Maintenance des tables et leur recouvrement

   Utilitaire pour vérifier et réparer les tables MyISAM (les tables avec les fichiers .MYI et MYD). Les même concepts s'appliquent à isamchk pour vérifier et réparer les tables ISAM (les tables avec les fichier .ISM et .ISD. myisamchk permet d'obtenir des informations sur les tables de la base de donnée, pour analyser, réparer ou optimiser ces tables. Bien penser à sauvegarder la base avant réparation d'une table. Les opérations qui affectent des index peuvent causer une recompilation des index FULLTEXT avec des paramètres qui ne sont pas les paramètres courants du serveur. Utiliser mysqlcheck pour les commandes, puisque le serveur se charge de tout alors qu'avec myisamchk, vous devez vous assurer que le serveur ne va pas utiliser les tables en même temps que vous.

syntaxe

shell› myisamchk [options] tbl_name
On peut spécifier plusieurs noms de table. On peut aussi spécifier un nom sous la forme d'un fichier d'index (avec l'option .MIY), qui permettra de spécifier toutes les tables dans un dossier en utilisant le schéma *.MIY. Par exemple
shell› myisamchk /path/to/database/*.MYI
Pour vérifier rapidement toutes les tables
myisamchk --silent --fast /path/to/datadir/*/*.MIY
isamchk --silent /path/to/datadir/*/*.ISM
Pour vérifier toutes les tables et réparer celles qui sont corrompue
myisamchk --silent --force --fast --update-state -O key_buffer=64M -O sort_buffer=64M -O read_buffer=1M -O write_buffer=1M /path/to/datadir/*/*.MYI
isamchk --silent --force -O key_buffer=64M -O sort_buffer=64M -O read_buffer=1M -O write_buffer=1M /path/to/datadir/*/*.ISM

   L'erreur suivante: myisamchk: warning: 1 clients is using or hasn't closed the table properly

   Signifie que vous essayez de vérifier une table qui a été modifiée par un autre programme (comme le serveur mysqld) qui n'a pas encore refermé le fichier de table, ou que le fichier n'a pas été correctement refermé. Si mysqld fonctionne, vous devez forcer la fermeture correcte des fichiers de tables avec la commande FLUSH TABLES, et vous assurer que personne n'utilise les tables durant vos opérations avec myisamchk.

Options générales de myisamchk

--debug=debug_options, -# debug_options Affiche le log de débogage. La chaîne debug_options vaut souvent : 'd:t:o,filename'.
--silent, -s Mode silencieux. Affiche uniquement les erreurs. Vous pouvez utiliser deux fois -s (-ss) pour que myisamchk soit très silencieux.
--verbose, -v Mode détaillé. Affiche plus d'informations. Vous pouvez combiner ce mode avec les options -d et -e. Utilisez -v plusieurs fois, (-vv, -vvv) pour plus de détails encore.
--version, -V Affiche la version et quitte.
--wait, -w Au lieu de s'arrêter avec une erreur si la table est verrouillé, le programme attend que la table soit libérée avant de continuer. Notez que si vous utilisez mysqld avec l'option --skip-external-locking, la table peut ne peut être verrouillée que par une autre commande myisamchk.

Options de vérifications pour myisamchk

-c, --check Vérifie les erreurs d'une table. Ceci est l'opération par défaut de myisamchk si vous ne lui donnez aucune autre option.
-e, --extend-check Vérifie la table minutieusement (ce qui est un peu lent si vous avez des index). Cette option ne doit être utilisée que pour les cas extrêmes. Normalement, myisamchk ou myisamchk --medium-check devrait, dans la plupart des cas, être capable de trouver s'il y a des erreurs dans la table. Si vous utilisez --extended-check et que vous avez beaucoup de mémoire, vous devez augmenter de beaucoup la valeur de key_buffer_size
-F, --fast Ne vérifie que les tables qui n'ont pas été fermées proprement.
-C, --check-only-changed Ne vérifie que les tables qui ont changé depuis la dernière vérification.
-f, --force Redémarrez myisamchk avec -r (répare) sur la table, si myisamchk trouve une erreur dans la table.
-i, --information Affiche des statistiques à propos de la table vérifiée.
-m, --medium-check Plus rapide que --extended-check, mais ne trouve que 99.99% des erreurs. Devrait, cependant, être bon pour la plupart des cas.
-U, --update-state Enregistre le fichier .MYI lorsque la table à été vérifiée ou a été corrompue. Cela devrait être utilisé pour tirer tous les avantages de l'option --check-only-changed, mais vous ne devez pas utiliser cette option si le serveur mysqld utilise cette table et que vous utilisez mysqld avec --skip-external-locking.
-T, --read-only Ne marque pas la table comme vérifiée. C'est pratique si vous utilisez myisamchk pour vérifier une table issue d'une autre application qui n'utilise pas les verrous. (comme mysqld --skip-external-locking).

Options de réparation de myisamchk

--backup, -B Fait une sauvegarde du fichier .MYD, sous le nom filename-time.BAK
--character-sets-dir=path Dossier qui contient les jeux de caractères.
--correct-checksum Somme de contrôle correcte pour la table.
--data-file-length=#, -D # Taille maximale du fichier de données (lors de la re-création du fichier de données, et qu'il est complet).
--extend-check, -e Essaie de retrouver toutes les lignes possibles du fichier de données. Normalement, cette option va aussi découvrir beaucoup de lignes erronées. N'utilisez pas cette option si vous n'êtes pas totalement désespérés.
--force, -f Écrase les anciens fichiers temporaires (table_name.TMD) au lieu d'annuler.
--keys-used=#, -k # Si vous utilisez les tables ISAM, indique au gestionnaire de table ISAM qu'il doit uniquement modifier les # premiers index. Si vous utilisez le gestionnaire de table MyISAM, cette option indique quelles clés utiliser, et chaque bit binaire représente une clé (la première clé est le bit 0). Cela permet de réaliser des insertions plus rapides. Les index désactivés pourront être réactivés avec l'option myisamchk -r.
--no-symlinks, -l Ne pas suivre les lignes symboliques. Normalement, myisamchk répare les tables qu'un lien symbolique représente.
--parallel-recover, -p Utilise la même technique que -r et -n, mais crée les clés avec des threads différents, en parallèle.
--quick, -q Réparation rapide, sans modifier le fichier de données. Il est possible d'ajouter l'option -q pour forcer myisamchk à modifier le fichier original en cas de clés doublons.
--recover, -r Peut réparer presque tout, sauf les clés uniques qui ne le sont plus (ce qui est extrêmement rare avec les tables ISAM/MyISAM). Si vous voulez restaurer un table, c'est l'option à utiliser en premier. Si myisamchk indique que la table ne peut pas être corrigée avec l'option -r, vous pouvez alors passer à l'option -o. Notez que dans le cas rarissime où -r, le fichier de données est toujours intact. Si vous avez beaucoup de mémoire, vous pouvez augmenter la taille du buffer sort_buffer_size
--safe-recover, -o Utilise une ancienne méthode de restauration (lit toutes les lignes dans l'ordre, et modifie l'arbre d'index conformément pour les lignes trouvées). C'est une méthode qui est beaucoup plus lente que l'option -r, mais elle est capable de traiter certaines situations exceptionnelles que -r ne pourrait pas traiter. Cette méthode utilise aussi moins d'espace disque que -r. Normalement, vous devriez commencer à réparer avec l'option -r, et uniquement sur l'échec de cette option, passer à -o. Si vous avez beaucoup de mémoire, vous devriez augmenter la taille du buffer de clé key_buffer_size
--set-character-set=name Change le jeu de caractères utilisé par l'index.
--sort-recover, -n Force myisamchk à utiliser le tri pour résoudre les clés, même si le fichier temporaire doit être énorme.
--tmpdir=path, -t path Chemin pour stocker les fichiers temporaires. Si cette option n'est pas fournie, myisamchk va utiliser la variable d'environnement TMPDIR pour cela.
--unpack, -u Décompresse des données compressées avec myisampack.

Autres options de myisamchk

-a, --analyze Analyse la distribution des clés. Cela améliore les performances des jointures en permettant à l'optimiseur de jointure de mieux choisir l'ordre d'utilisation des clés. myisamchk --describe --verbose table_name' ou SHOW KEYS dans MySQL.
-d, --description Affiche des informations sur la table.
-A, --set-auto-increment[=value] Force AUTO_INCREMENT à commencer avec une valeur supérieure. Si aucune valeur n'est fournie, la prochaine valeur de la colonne AUTO_INCREMENT sera la plus grande valeur de la colonne +1.
-S, --sort-index Trie les blocs de l'arbre d'index dans l'ordre haut/bas. Cela va optimiser les recherches, et les scans de tables par clés.
-R, --sort-records=# Trie les lignes en fonction de l'index. Cela rassemble vos données, et peut accélérer les lectures de lignes par intervalle avec SELECT et ORDER BY sur cet index (ce tri peut être très lent la première fois). Pour connaître les numéros d'index de tables, utilisez la commande SHOW INDEX, qui affiche les index dans le même ordre que myisamchk ne les voit. Les index sont numérotés à partir de 1.

L'espace mémoire est très important quand on utilise myisamchk
myisamchk -O sort=16M -O key=16M -O read=1M -O write=1M ...
myisamchk utilise des fichiers temporaires dans le dossier TEMPDIR. Lors de la réparation, il va aussi avoir besoin d'espace disque.

Utiliser myisamchk pour restaurer une table

   si mysqld a l'option --skip-external-locking, on ne peut pas utiliser myisamchk pour vérifier une table. Si vous utilisez myisamchk pour réparer ou optimiser les tables, vous devez toujours vous assurer que mysqld n'utilise pas cette table

Vérifier la cohérence d'une table

cette commande trouvera 99,9% des erreurs
myisamchk nom_de_table
cette commande trouvera 99,999% des erreurs
myisamchk -m nom_de_table
cette commande fait une vérification complète et exhaustive de toutes les données
myisamchk -e nom_de_table
idem mais affiche des informations statistiques
myisamchk -e -i nom_de_table

Réparer les tables

On peut réparer les tables MyISAM avec REPAIR TABLE. Les symptômes de corruption de tables sont des requêtes qui s'interrompent inopinément
tbl_name.frm locked against change: tbl_name.frm est verrouillée en écriture
Can't find file tbl_name.MYI (Errcode : ###): Impossible de trouver le fichier tbl_name.MYI (Errcode: ###)
Unexpected end of file: Fin de fichier inattendue
Record file is crashed: Fichier de données crashé
Got error ### from table handler: Reception de l'erreur ### de la part du gestionnaire de table
Pour obtenir plus d'informations sur l'erreur, vous pouvez exécuter la commande perror

Optimisation de table

Pour réorganiser les lignes fragmentées et éliminer l'espace perdu par les effacements et les modifications
shell› myisamchk -r table_name
de la même manière OPTIMIZE TABLE effectue une réparation de la table, et une analyse des index, puis trie l'arbre d'index pour accélérer les recherches de clé.
myisamchk dispose aussi d'un grand nombre d'options à utiliser pour améliorer les performances de la table
-S, --sort-index
-R index_num, --sort-records=index_num
-a, --analyse
Mettre en place un régime d'entretient de MySQL. Vérifier par un cron une fois par semaine
35 0 * * 0 /path/to/myisamchk --fast --silent /path/to/datadir/*/*.MYI
Défragmentation du fichier, mysqld éteint
shell› myisamchk -r -s --sort-index -O sort_buffer_size=16M */*.MYI
Pour les tables ISAM, la commande est similaire à
shell› isamchk -r -s --sort-index -O sort_buffer_size=16M */*.MYI

Obtenir des informations sur une table

Exécute myisamchk en "mode description" pour produire une description de votre table
myisamchk -d nom_de_table
Pour produire plus d'informations durant l'exécution de myisamchk
myisamchk -d -v nom_de_table
Affiche les informations les plus importantes pour une table
myisamchk -eis nom_de_table
C'est l'équivalent de -eis, mais qui vous indique ce qui se passe
myisamchk -eiv nom_de_table
^
08 mai 2010

htmlpdflatexmanmd




myisampack

myisampack, pack_isam

Compresser les tables myisam et isam

   myisampack sert à compresser des tables myisam et pack_isam sert à compresser les tables isam. myisampack fonctionne en compressant séparément chaque colonne de la table. myisampack compresse le fichier avec un gain de 40 à 70%.

- 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.
- Une fois compressé, la table n'est plus accessible qu'en lecture seule.
- Myisampack peut aussi compresser les colonnes BLOB et TEXT.

OPTIONS

--backup, -b fait une sauvegarde de la table sous le nom tbl_name.OLD
--force, -f force la compression de la table, même si elle grossit ou si le fichier temporaire existe déjà. Crée alors un fichier tbl_name.TMD lors de la compression.
--join=big_tbl_name, -j big_tbl_name rassemble toutes les tables indiquées dans une seule table appelée big_tbl_name. Toutes les tables appelées doivent être identiques (même noms de colonnes, même types, même index, etc...)
--packlengh=#, -p # Spécifie la taille de stockage de la longueur de ligne, en octets (valeur : 1, 2 ou 3) stocke toutes les lignes avec des pointeurs de lignes de 1, 2 ou 3 octets.
--silent, -s mode silencieux, seules les erreurs seront affichées
--test, -t test simplement la compression
--tmp_dir=path, -T path utilise le dossier temporaire indiqué
--verbose, -v mode détaillé
--wait, -w attend et réessaie, si la table était déjà en cour d'utilisation
^
08 mai 2010

htmlpdflatexmanmd




mysql

mysql

Client MySQL

OPTIONS

--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ées.
--compress, _C Utilise la compression avec le protocole client/serveur
--database=db_name, -D db_name La base de données à utiliser, particulièrement pratique dans my.cnf
--debug[=debug_options], -# [debug_options] génère un log de débogage. debug_options vaut souvent 'd:t:o,file_name'. Par défaut : 'd:t:o,/tmp/mysql.trace'
--debug-info, -T Affiche des informations de débogage lorsque le programme se termine.
--default-character-set=charset Jeu de caractère par défaut
--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.
--local-infile[=0|1] active ou désactive la possibilité d'utiliser la commande LOCAL pour LOAD DATA INFILE
--named-commands, -G les commandes nommées sont activées. activé par défaut. avec l'option -g le format long des commandes fonctionne.
--no-auto-rehash, -A pas de rehashage automatique, mysql se lance plus rapide, mais vous devez utiliser rehash pour utiliser la complétion de noms de tables.
--no-beep, -b ne fait pas de bips en cas d'erreur
--no-named-commands, -g désactive les commandes nommées
--no-pager désactive le système de page, et affiche directement dans la sortie standard.
--no-tee Désactive le fichier de sortie
--one-database, O ne modifie que la base par défaut. Pratique pour éviter les modifications dans les autres bases dans le fichier de log.
--pager[=command] type d'affichage. les pageurs valides sont less, more, cat (› filename), etc.
--password[=password), -p[password] mot de passe de connexion au serveur.
--port=port_num, -P port_num numéro de port TCP pour la connexion.
--prompt=format_str modifie le format de l'invite de commande
--protocol=TCP|SOCKET|PIPE|MEMORY spécifie le protocole de connexion à utiliser
--quick, -q ne met pas en cache le résultat, et l'affiche ligne par ligne. N'utilise pas le fichier d'historique.
--raw, -r écrit les valeurs des colonnes dans les conversions de protections, utilisé en mode --batch
--reconnect si la connexion est perdue, essaie de se reconnecter automatiquement au serveur, une seule fois. Pour supprimer la reconnexion automatique, utiliser --skip-reconnect.
--safe-updates, --i-am-a-dummy, -U N'autorise que les commandes UPDATE et DELETE qui utilisent des clés. --safe-updates pour annuler.
--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. Pratique pour comparer des résultats qui incluent des messages d'erreurs.
--socket=path, -S path Le fichier de socket à utiliser pour la connexions
--table, -t affichage au format de table. mode par défaut pour le mode non-batch
--tee=file_name ajoute tout dans le fichier de sortie. ne fonctionne qu'en mode batch
--unbuffered, -n vide le buffer de requête après chaque requêtes
--user=user_name, -u user_name nom d'utilisateur pour la connexion.
--verbose, -v mode verbeux
--vertical, -E affiche le résultat d'une requête verticalement. sans l'option, utiliser \G pour obtenir le même résultat.
--wait, -w attend et retente si la connexion s'interrompt au lieu de quitter.
--xml, -X affiche le résultat au format XML, put également se spécifier par --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.

Exemples avec pager

Écrire les résultats dans un fichier
mysql› pager cat › /tmp/log.txt
passer les options que le page comprendra
mysql› pager less -n -i -S
-S de less rend le résultat plus lisible
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 dans deux répertoires /dr1 et /dr2, mais affichera toujours le résultat à l'écran via less.
mysql› pager cat | tee /dr1/tmp/res.txt | tee /dr2/tmp/res2.txt | less -n -i -S

Exemple pour le prompt

\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

Exemple avec la variable d'environnement MYSQL_PS1

shell› export MYSQL_PS1="(\u@\h) [\d]› "
ou dans le fichier d'options
[mysql]
prompt=(\\u@\\h) [\\d]›\\_
^
04 mai 2010

htmlpdflatexmanmd




MySQL - concept général

MySQL - concept général

Système de gestion de base de données

   MySQL est un système de gestion de base de données, un serveur de bases de données relationnelles. Une base de données est un ensemble organisé de données. SQL signifie « Structured Query Language »

Emplacement des fichiers

/usr/bin Programmes clients
/usr/sbin serveur mysqld
/var/lib/mysql Fichiers de log et bases de données
/usr/share/doc/packages Documentation
/usr/share/mysql Fichiers de messages d'erreurs et jeux de caractères
sql-bench Suites de tests

Comptes par défaut

   Le script mysql_install_db démarre le serveur mysqld et initialise les tables de droits, avec les paramètres suivants:

  Deux comptes MySQL root sont créés en tant qu'administrateurs ayant tous les droits. Le mot de passe de l'utilisateur initial root est vide ou définit pendant l'installation.

  Deux comptes utilisateur anonyme sont créés, qui peuvent faire ce qu'ils veulent avec toutes les tables dans la base de données 'test' ou commençant par 'test_'. Cela signifie qu'un utilisateur peut se connecter sans mot de passe et être traité comme un utilisateur anonyme.

  Les connexions doivent être faîtes en spécifiant le nom d'hôte. Ces comptes ont tous les droits dans les bases test ou dont le nom commence par test_.

Pour modifier les mots de passe utiliser SET PASSWORD
shell› mysql -u root
mysql› SET PASSWORD FOR ''@'localhost' = PASSWORD('nouveau_mot') ;
mysql› SET PASSWORD FOR ''@'host_name' = PASSWORD('nouveau_mot') ;
Pour connaître le host_name taper
mysql› SELECT Host, User FROM mysql.user ;
On peut utiliser la commande UPDATE pour changer les mots de passe des comptes anonymes.
shell› mysql -u root
mysql› UPDATE mysql.user SET Password = PASSWORD('nouveau_mot') WHERE User = '' ;
flush privileges demande au serveur de relire les tables de droits
mysql› FLUSH PRIVILEGES ;
si on préfère supprimer les comptes anonymes
shell› mysql -u root
mysql› DELETE FROM mysql.user WHERE User = '' ;
mysql› FLUSH PRIVILEGES ;

Introduction

Connexion au serveur MySql
mysql -h hote -u utilisateur -p
pour se déconnecter
QUIT ou EXIT
pour obtenir le numéro de version du serveur MySQL
SELECT VERSION(), CURRENT_DATE ;
entrer plusieurs requêtes sur une seule ligne
SELECT VERSION() ; SELECT NOW() ;
entrer une commande sur plusieurs, ligne : la fin d'une requête se termine par ' ;'
mysql› SELECT
-› USER()
-› ,
-› CURRENT_DATE ;
Annuler une requête en cour de frappe, sur une seule ligne taper
\c
afficher les bases de données existantes
SHOW DATABASES ;
accéder à une base
use test
créer une base de donnée
create database test ;
se connecter à mysql directement dans une base
mysql -u utilisateur -ppassword test
créer une table
CREATE TABLE animal (nom VARCHAR(20), maitre VARCHAR(20),
-› espece VARCHAR(20), sexe CHAR(1), naissance DATE, mort DATE) ;
pour afficher la structure de la table
describe animal ;
créer un fichier pour remplir une table, chaque champ doit être séparé par une tabulation
pour importer un fichier dans une table :
LOAD DATA LOCAL INFILE "animal.txt" INTO TABLE animal ;
ajouter des enregistrement un par un (utiliser NULL pour indiquer une valeur manquante)
mysql› INSERT INTO animal
-› VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL) ;
récupérer des informations
SELECT quoi_selectionner
FROM quel_table
WHERE conditions_a_satisfaire
pour tout sélectionner
SELECT * from animal ;
corriger une erreur dans une table, il existe au moins 2 façons de le faire. la première consiste a vider la table, corriger le fichier et le recharger
mysql› SET AUTOCOMMIT=1 ; # Utilisé pour une recréation rapide de la table
mysql› DELETE FROM animal ;
mysql› LOAD DATA LOCAL INFILE "animal.txt" INTO TABLE animal ;
ou corriger l'enregistrement avec update
mysql› UPDATE animal SET naissance = "1989-08-31" WHERE nom = "Bowser" ;
sélectionner des lignes particulières :
mysql› SELECT * FROM animal WHERE nom = "Bowser" ;
avec les booléennes
mysql› SELECT * FROM animal WHERE espece = "chien" AND sexe = "f" ;
plus complexe
mysql› SELECT * FROM animal WHERE (espece = "chat" AND sexe = "m")
-› OR (espece = "chien" AND sexe = "f") ;
sélectionner des colonnes
mysql› SELECT nom, naissance FROM animal ;
pour minimiser le résultat à des champs uniques utiliser DISTINCT
mysql› SELECT DISTINCT maitre FROM animal ;
trie des enregistrements
mysql› SELECT nom, naissance FROM animal ORDER BY naissance ;
pour trier en respectant la casse
mysql› SELECT nom, naissance FROM animal ORDER BY BINARY naissance ;
pour trier dans l'ordre décroissant
mysql› SELECT nom, naissance FROM animal ORDER BY naissance DESC ;
on peut trier sur plusieurs colonnes
mysql› SELECT nom, espece, naissance FROM animal ORDER BY espece, naissance DESC ;
ici l'ordre décroissant n'est appliqué qu'à naissance.

Calcul des Dates

Pour calculer l'âge par rapport à une date de naissance, il faut calculer la différence entre l'année en cour et l'année de naissance, puis soustraire la date courante si la date du jour se produit plus tôt dans l'année civile que la date de naissance
mysql› SELECT nom, naissance, CURRENT_DATE,
-› (YEAR(CURRENT_DATE)-YEAR(naissance))
-› - (RIGHT(CURRENT_DATE,5)‹RIGHT(naissance,5))
-› AS age
-› FROM animal ;
YEAR extrait l'année de la date et RIGHT(naissance,5) extrait les 5 caractères les plus à droite de la date qui représente MM-DD (année civile).
Pour calculer l'âge d'un animal à sa mort, s'il est déjà mort
mysql› SELECT nom, naissance, mort,
-› (YEAR(mort)-YEAR(naissance)) - (RIGHT(mort,5)‹RIGHT(naissance,5))
-› AS age
-› FROM animal WHERE mort IS NOT NULL ORDER BY age ;
si l'animal est mort, le champ mort est différent de NULL.
pour afficher dans combien de mois est leur anniversaire
mysql› SELECT nom, naissance, MONTH(naissance) FROM animal ;
ceux dont l'anniversaire est dans 5 mois :
mysql› SELECT nom, naissance FROM animal WHERE MONTH(naissance) = 5 ;
autres valeurs utilisables : YEAR(), MONTH(), et DAYOFMONTH().
on peut utiliser des fonctions de calcul d'intervalle
mysql› SELECT nom, naissance FROM animal
-› WHERE MONTH(naissance) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH)) ;
autre manière pour un résultat similaire
mysql› SELECT nom, naissance FROM animal
-› WHERE MONTH(naissance) = MOD(MONTH(NOW()), 12) + 1 ;
valeur NULL : on ne peut pas utiliser de comparateur : '=', '‹', '›' ou '‹›'. il faut utiliser IS NULL ou IS NOT NULL.

Recherche de modèles

'_' représente n'importe quel caractère, '%' un nombre arbitraire de caractères. on n'utilise pas = ni ‹› mais LIKE et NOT LIKE.
mysql› SELECT * FROM animal WHERE nom LIKE "b%" ;
mysql› SELECT * FROM animal WHERE nom LIKE "%w%" ;
mysql› SELECT * FROM animal WHERE nom LIKE "_____" ;
les expressions régulières étendues. avec ce type de modèle, utiliser REGEXP et NOT REGEXP ou RLIKE et NOT RLIKE
'.' représente n'importe quel caractère, [...] n'importe quel caractère inclus entre les crochets, fonctionne aussi comme [a-z].
'*' nombre arbitraire de caractère, '^' pour spécifier en début de chaîne ou '$' en fin de chaîne. REGEXP n'est pas sensible à la casse, utiliser binary pour la respecter.
mysql› SELECT * FROM animal WHERE nom REGEXP "^b" ;
mysql› SELECT * FROM animal WHERE nom REGEXP "^[bB]" ;
mysql› SELECT * FROM animal WHERE nom REGEXP BINARY "^b" ;
mysql› SELECT * FROM animal WHERE nom REGEXP "fy$" ;
REGEXP cherche le motif recherché donc pas besoin de * au contraire de LIKE :
mysql› SELECT * FROM animal WHERE nom REGEXP "w" ;
pour recherche une chaîne exacte : .n signifie répéter n fois.
mysql› SELECT * FROM animal WHERE nom REGEXP "^.....$" ;
mysql› SELECT * FROM animal WHERE nom REGEXP "^.5$" ;

Compter les lignes

La fonction COUNT() compte le nombre de résultats non NULL
mysql› SELECT COUNT(*) FROM animal ;
mysql› SELECT maitre, COUNT(*) FROM animal GROUP BY maitre ;
la clause GROUP BY est nécessaire pour grouper tous les enregistrements par maître, sinon on a une erreur
mysql› SELECT espece, sexe, COUNT(*) FROM animal GROUP BY espece, sexe ;
mysql› SELECT espece, sexe, COUNT(*) FROM animal
-› WHERE espece = "chien" OR espece = "chat"
-› GROUP BY espece, sexe ;
mysql› SELECT espece, sexe, COUNT(*) FROM animal
-› WHERE sexe IS NOT NULL
-› GROUP BY espece, sexe ;

Utiliser plus d'une table

mysql› SELECT animal.nom,
-› (TO_DAYS(date) - TO_DAYS(naissance))/365 AS age, remarque
-› FROM animal, evenement
-› WHERE animal.nom = evenement.nom AND type = "mise bas" ;
on peut joindre une table sur elle-même
mysql› SELECT p1.nom, p1.sexe, p2.nom, p2.sexe, p1.espece
-› FROM animal AS p1, animal AS p2
-› WHERE p1.espece = p2.espece AND p1.sexe = "f" AND p2.sexe = "m" ;
Obtenir des informations à propos des bases de données et des tables
Show databases
montrer dans quelle base on est
select database()
montrer les tables
Show Tables
afficher les champs de la table
Describe animal

Utilisation de mysql en mode batch

Pour utiliser mysql en mode batch, placer les commandes dans un fichier et utiliser la commande
mysql ‹ fichier-batch
capturer l'affichage
mysql ‹ fichier.batch › mysql.out
la sortie en mode batch est différente du mode interactif, pour obtenir le même affichage utiliser l'option mysql -t . Pour écrire les commandes
mysql -vvv.
pour exécuter un fichier depuis la commande
source nom_fichier

Exemples de requêtes usuelles

valeur maximale d'une colonne
SELECT MAX(article) AS article FROM shop
la ligne contenant le maximum d'une certaine colonne
SELECT article, dealer, price FROM shop WHERE price=(SELECT MAX(price) FROM shop) ;
la même chose en triant dans l'ordre décroissant, puis afficher la première ligne
SELECT article, dealer, price FROM shop ORDER BY price DESC LIMIT 1 ;
maximum d'une colonne par groupe
SELECT article, MAX(price) AS price FROM shop GROUP BY article
la ligne contenant la plus grande valeur d'un certain champ par rapport à un groupe
SELECT article, dealer, price FROM shop s1 WHERE price=(SELECT MAX(s2.price) FROM shop s2 WHERE s1.article = s2.article) ;
la même en plusieurs étapes, en créant une table temporaire
CREATE TEMPORARY TABLE tmp (
article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
price DOUBLE(16,2) DEFAULT '0.00' NOT NULL) ;
LOCK TABLES shop read ;
INSERT INTO tmp SELECT article, MAX(price) FROM shop GROUP BY article ;
SELECT shop.article, dealer, shop.price FROM shop, tmp
WHERE shop.article=tmp.article AND shop.price=tmp.price ;
UNLOCK TABLES ;
DROP TABLE tmp ;
ou encore (en une étape)
SELECT article,
SUBSTRING( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 7) AS dealer,
0.00+LEFT( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 6) AS price
FROM shop
GROUP BY article ;
Utiliser les variables utilisateur. Trouver l'article avec le plus haut et le plus bas prix
mysql› SELECT @min_price :=MIN(price),@max_price :=MAX(price) FROM shop ;
mysql› SELECT * FROM shop WHERE price=@min_price OR price=@max_price ;
utiliser les clés étrangères
CREATE TABLE person (
id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
name CHAR(60) NOT NULL,
PRIMARY KEY (id)
) ;
CREATE TABLE shirt (
id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
style ENUM('t-shirt', 'polo', 'dress') NOT NULL,
color ENUM('red', 'blue', 'orange', 'white', 'black') NOT NULL,
owner SMALLINT UNSIGNED NOT NULL REFERENCES person(id),
PRIMARY KEY (id)
) ;
INSERT INTO person VALUES (NULL, 'Antonio Paz') ;
INSERT INTO shirt VALUES
(NULL, 'polo', 'blue', LAST_INSERT_ID()),
(NULL, 'dress', 'white', LAST_INSERT_ID()),
(NULL, 't-shirt', 'blue', LAST_INSERT_ID()) ;
INSERT INTO person VALUES (NULL, 'Lilliana Angelovska') ;
INSERT INTO shirt VALUES
(NULL, 'dress', 'orange', LAST_INSERT_ID()),
(NULL, 'polo', 'red', LAST_INSERT_ID()),
(NULL, 'dress', 'blue', LAST_INSERT_ID()),
(NULL, 't-shirt', 'white', LAST_INSERT_ID()) ;

SELECT * FROM person ;
+----+---------------------+
|-id-|---------name--------|
+----+---------------------+
|--1-|-Antonio-Paz---------|
|--2-|-Lilliana-Angelovska-|
+----+---------------------+

SELECT * FROM shirt ;
+----+---------+--------+-------+
|-id-|--style--|-color--|-owner-|
+----+---------+--------+-------+
|--1-|-polo----|-blue---|----1--|
|--2-|-dress---|-white--|----1--|
|--3-|-t-shirt-|-blue---|----1--|
|--4-|-dress---|-orange-|----2--|
|--5-|-polo----|-red----|----2--|
|--6-|-dress---|-blue---|----2--|
|--7-|-t-shirt-|-white--|----2--|
+----+---------+--------+-------+

SELECT s.* FROM person p, shirt s WHERE p.name LIKE 'Lilliana%' AND s.owner = p.id AND s.color ‹› 'white' ;
+----+-------+--------+-------+
|-id-|-style-|-color--|-owner-|
+----+-------+--------+-------+
|--4-|-dress-|-orange-|-2-----|
|--5-|-polo--|--red---|-2-----|
|--6-|-dress-|-blue---|-2-----|
+----+-------+--------+-------+

Recherche sur deux clefs
SELECT champ1_index, champ2_index FROM test_table WHERE champ1_index = '1'
OR champ2_index = '1'
avec UNION
SELECT field1_index, field2_index FROM test_table WHERE field1_index = '1'
UNION
SELECT field1_index, field2_index FROM test_table WHERE field2_index = '1' ;
calcul du nombre de visites par jour
CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL,
day INT(2) UNSIGNED ZEROFILL) ;
INSERT INTO t1 VALUES(2000,1,1),(2000,1,20),(2000,1,30),(2000,2,2),
(2000,2,23),(2000,2,23) ;
SELECT year,month,BIT_COUNT(BIT_OR(1‹‹day)) AS days FROM t1
GROUP BY year,month ;
Utiliser AUTO_INCREMENT. L'attribut AUTO_INCREMENT peut être utilisé pour générer un identifiant unique pour les nouvelles lignes
CREATE TABLE animals (
id MEDIUMINT NOT NULL AUTO_INCREMENT,
name CHAR(30) NOT NULL,
PRIMARY KEY (id)
) ;
INSERT INTO animals (name) VALUES ("dog"),("cat"),("penguin"),
("lax"),("whale"),("ostrich") ;
SELECT * FROM animals ;
On peut récupérer la valeur utilisée de la clé AUTO_INCREMENT avec la fonction LAST_INSERT_ID() ou la fonction API mysql_insert_id().
Pour les tables MyISAM et BDB on peut spécifier AUTO_INCREMENT sur une colonne secondaire d'une clef multi-colonnes. Dans ce cas la valeur généré est calculée de la façon suivante :
MAX(auto_increment_column)+1) WHERE prefix=given-prefix .
Utile lorsqu'on veut placer des données dans des groupes ordonnés.
CREATE TABLE animals (
grp ENUM('fish','mammal','bird') NOT NULL,
id MEDIUMINT NOT NULL AUTO_INCREMENT,
name CHAR(30) NOT NULL,
PRIMARY KEY (grp,id)
) ;
INSERT INTO animals (grp,name) VALUES("mammal","dog"),("mammal","cat"),
("bird","penguin"),("fish","lax"),("mammal","whale"),
("bird","ostrich") ;
SELECT * FROM animals ORDER BY grp,id ;

Qui retourne :
+--------+----+---------+
|--grp---|-id-|-name----|
+--------+----+---------+
|-fish---|--1-|-lax-----|
|-mammal-|--1-|-dog-----|
|-mammal-|--2-|-cat-----|
|-mammal-|--3-|-whale---|
|-bird---|--1-|-penguin-|
|-bird---|--2-|-ostrich-|
+--------+----+---------+

Utilisation de MySQL avec Apache

Pour changer le format d'archivage d'Apache dans MySQL pour le rendre plus lisible, mettre ceci dans la configuration d'Apache :
LogFormat \
"\"%h\",%%Y%m%d%H%M%St,%›s,\"%b\",\"%Content-Typeo\", \
\"%U\",\"%Refereri\",\"%User-Agenti\""
Avec MySQL, vous pouvez exécuter une requête de cette manière :
LOAD DATA INFILE '/local/access_log' INTO TABLE table_name
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' ESCAPED BY '\\'

Administration du serveur

mysqld est le serveur MySQL
mysqld-max version du serveur qui inclut des fonctionnalités supplémentaires
mysqld-safe est un script de démarrage du serveur. Tente de démarrer mysqld-max s'il existe sinon mysqld.
mysql.server est un script de démarrage du serveur, utilisé sur les systèmes qui ont un dossier contenant des services système. Il invoque mysqld-safe pour démarrer le serveur.
mysqld_multi est un script de démarrage qui peut lancer ou arrêter différentes instances du serveur, installées sur le système.
mysql_install_db crée les tables de droits MySQL, avec les droits par défaut.
mysql_fix_privilege_tables script utilisé après une mise à jour de MySQL pour mettre à jour les tables de droits, et les adapter aux nouvelles versions de MySQL.
myisamchk utilitaire pour décrire, vérifier, optimiser et réparer les tables MyISAM
make_binary_distribution crée une version compilée de MySQL.
mysqlbug script de rapport de bug de MySQL.

   Pour connaître les moteurs de stockage que votre serveur supporte, utiliser la commande SHOW ENGINES; safe_mysqld est la méthode recommandée pour démarrer un démon mysqld. Il ajoute des fonctionnalités de sécurité telles que le redémarrage automatique lorsqu'une erreur survient et l'enregistrement d'informations d'exécution dans un fichier de log. Par défaut il essaie de lancer mysqld-max s'il existe. Pour remplacer le comportement par défaut et spécifier explicitement le serveur à utiliser, spécifier --mysqld ou --mysqld-version.

Le mode SQL du serveur

   Le serveur MySQL peut fonctionner avec différents modes SQL, et peut s'appliquer au niveau de la connexion du client. Cela permet aux applications d'adapter le comportement du serveur en fonction de leur attentes. Le mode définit quelle syntaxe SQL le serveur doit supporter, et quels types de vérification il doit faire. Pour donner un mode par défaut au démarrage : --sql-mode="modes". On peut modifier le mode à chaud avec SET [SESSION|GLOBAL] sql_mode='modes'

Modes

ANSI change la syntaxe et le comportement pour être plus compatible avec le standard SQL
STRICT_TRANS_TABLES Si une valeur n'a pu être insérée dans une table transactionnelle sans modification, la commande est annulée. Pour une tables non-transactionnelle, la commande est annulée si cela survient dans une ligne unique ou dans la première ligne d'une insertion multiple.
TRADITIONAL le serveur se comporte comme un système SQL traditionnel
ALLOW_INVALID_DATES N'autorise pas la vérification totale des dates. Vérifie simplement que le mois est dans l'intervalle de 1 à 12, et que le jour est dans l'intervalle de 1 à 31. C'est très pratique pour les applications Web où la date est obtenue de 3 champs différents, et que vous voulez stocker exactement la date saisie sans validation. Ce mode s'applique aux colonnes de type DATE et DATETIME. Il ne s'applique pas aux colonnes TIMESTAMP, qui demandent toujours une date valide.
ANSI_QUOTES Traite ‘"’ comme un délimiteur d'identifiant (comme le caractère MySQL ‘`’) et non comme un délimiteur de chaînes. Vous pouvez toujours utiliser ‘`’ pour délimiter les identifiants en mode ANSI. Avec ANSI_QUOTES activée, vous ne pouvez pas utiliser les guillemets doubles pour délimiter une chaîne de caractères, car ce sera uniquement interprété comme un identifiant.
ERROR_FOR_DIVISION_BY_ZERO Produit une erreur en mode strict et sinon une alerte, lorsque MySQL doit tenter une division par 0 ou un MOD(X,0)) durant une commande INSERT/ UPDATE. Si ce mode n'est pas activé, MySQL retourne simplement NULL pour les divisions par zéro. Si utilisé avec l'attribut IGNORE, MySQL génère une alerte pour les divisions par zéro, mais le résultat de l'opération sera NULL
IGNORE_SPACE Permet les espaces entre le nom de la fonction et le caractère ‘(’. Cela force les noms de fonctions a être traités comme des mots réservés. En conséquence, si vous voulez accéder aux bases, tables et colonnes dont le nom est un mot réservé, vous devez le mettre entre délimiteurs.
NO_AUTO_VALUE_ON_ZERO affecte la gestion des colonnes de type AUTO_INCREMENT. Normalement, vous générez le prochain numéro de séquence dans la colonne en insérant soit NULL soit 0 dedans. NO_AUTO_VALUE_ON_ZERO supprime ce comportement pour 0 pour que seule la valeur NULL génère le prochain numéro de séquence. Ce mode est utile si vous avez stocké la valeur 0 dans la colonne AUTO_INCREMENT de la table. Ce n'est pas recommandé. Par exemple, si vous voulez exporter une table avec mysqldump et que vous la rechargez, normalement MySQL va générer de nouveaux identifiants pour les lignes avec la valeur 0, ce qui entraînera une différence avec la table originale. En activant NO_AUTO_VALUE_ON_ZERO avant de recharger le fichier exporter, vous évitez des problèmes. mysqldump va automatiquement inclure les commandes nécessaires dans l'export, pour activer NO_AUTO_VALUE_ON_ZERO.
NO_DIR_IN_CREATE Lors de la création d'une table, ignore les directives INDEX DIRECTORY et DATA DIRECTORY. Cette option est pratique sur un esclave de réplication.
NO_FIELD_OPTIONS N'affiche pas les options spécifiques à MySQL dans le résultat de SHOW CREATE TABLE. Ce mode est utilisé par mysqldump dans un souci de portabilité
NO_KEY_OPTIONS N'affiche pas les options spécifiques à MySQL dans le résultat de SHOW CREATE TABLE. Ce mode est utilisé par mysqldump dans un souci de portabilité.
NO_TABLE_OPTIONS N'affiche pas les options de tables spécifiques à MySQL (comme ENGINE) dans le résultat de SHOW CREATE TABLE. Ce mode est utilisé par mysqldump dans un souci de portabilité.
NO_ZERO_DATE Ne permet pas l'utilisation de '0000-00-00' comme date valide. Vous pouvez toujours insérer des dates nulles avec l'option IGNORE. NO_ZERO_IN_DATE N'accepte pas les dates où le mois ou le jour vaut 0. Si utilisé avec L'option IGNORE, la date '0000-00-00' sera insérée pour chaque date invalide.
NO_UNSIGNED_SUBTRACTION Dans les opérations de soustraction, ne marque pas le résultat UNSIGNED si un des opérandes est non signé. Notez que cela fait que UNSIGNED BIGINT n'est plus totalement utilisable dans tous les contextes.
ONLY_FULL_GROUP_BY N'autorise pas les requêtes dont la clause GROUP BY fait référence à une colonne qui n'est pas sélectionnée.
PIPES_AS_CONCAT Traite || comme un opérateur de concaténation (identique à CONCAT()) au lieu d'être un synonyme de OR.
REAL_AS_FLOAT Traite le type REAL comme un synonyme FLOAT plutôt que comme un synonyme de DOUBLE.
STRICT_ALL_TABLES Active le mode strict pour tous les moteurs de stockage. Les valeurs invalides sont rejetées. Plus de détails suivent.
STRICT_TRANS_TABLES Active le mode strict pour tous les moteurs de stockage transactionnels. Les valeurs invalides sont rejetées. Plus de détails suivent.

Variables système dynamique

modifier une variable au lancement du serveur
mysqld --key_buffer_size=16M
modifier une variable à chaud
mysql› SET sort_buffer_size = 10 * 1024 * 1024 ;
Spécifier explicitement s'il s'agit d'une variable global ou de session
mysql› SET GLOBAL sort_buffer_size = 10 * 1024 * 1024 ;
mysql› SET SESSION sort_buffer_size = 10 * 1024 * 1024 ;
Voir les variables du serveur
SHOW variables
Affiche des informations sur le statut du serveur
SHOW STATUS
Remet à 0 de nombreuses variables de status
FLUSH STATUS
Arrêter le serveur: si un utilisateur a les droit SHUTDOWN il peut arrêter le serveur avec
mysqladmin shutdown

Sécurité général du serveur

   MySQL dispose d'un système de sécurité basé sur des liste de contrôle d'accès (ACL) pour toutes les connexions, requêtes et opérations que l'utilisateur peut faire. Il y'a aussi le support des connexions SSL entre le client et le serveur MySQL.

  Suivre les règles suivante:

- Ne donnez jamais à personne (sauf au compte MySQL root ) accès à la table user de la base mysql !. Le mot de passe chiffré est le vrai mot de passe de MySQL.
- Apprenez le système de droits MySQL. Les commandes GRANT et REVOKE sont utilisés pour contrôler les accès à MySQL. Ne donnez pas plus de droits nécessaire. Ne donnez jamais de droits à tous les serveurs hôtes.
- Ne stockez jamais de mot de passe en clair dans votre base. À la place, utilisez MD5(), SHA1() ou une autre fonction de signature injective
- utilisez des mots de passe fort.
- Placez votre serveur derrière un parefeu

Liste de vérification

- Essayez la commande mysql -u root sans mot de passe
- Utilisez la commande SHOW GRANTS et vérifiez qui a accès à quoi. Puis utilisez la commande REVOKE pour retirer les droits inutiles.

Protéger MySQL contre les attaques

   Toutes les informations autre que les mots de passes sont transférées en clair. Pour sécuriser le traffic, il est recommandé d'utiliser le protocole compressé et d'utiliser ssh pour établir des connexions chiffrées.

- N'exécutez jamais le démon MySQL avec l'utilisateur root. Pour démarrer mysqld sous un autre nom d'utilisateur Unix, ajoutez la ligne user qui spécifie le nom de l'utilisateur, dans le fichier d'options de [mysqld] de /etc/my.cnf.
- N'autorisez pas l'utilisation de liens symboliques pour les tables. Cette fonctionnalité peut être désactivée avec l'option --skip-symbolic-links. C'est particulièrement important si vous utilisez mysqld comme root, car tout utilisateur a alors le droit d'écrire des données sur le disque, n'importe où sur le système !!
- Vérifiez que l'utilisateur Unix qui exécute mysqld est le seul utilisateur avec les droits de lecture et écriture dans le dossier de base de données.
- Ne donnez pas le droit de PROCESS à tous les utilisateurs. Le droit SUPER peut être utilisé pour fermer des connexions clients, changer les variables systèmes et contrôler la réplication.
- Ne donnez pas le droit de FILE à tous les utilisateurs. Tout utilisateur qui possède ce droit peut écrire un fichier n'importe où sur le serveur, avec les droits hérités du démon mysqld.
- Si vous voulez restreindre le nombre de connexions d'un utilisateur, vous pouvez le faire en utilisant la variable max_user_connections de mysqld. La commande GRANT dispose aussi d'options de contrôle des ressources, pour limiter l'utilisation du serveur par un compte utilisateur.

Options de démarrage qui concerne la sécurité

--local-infile[=(0|1)] si vous utilisez --local-infile=0 alors vous ne pourrez pas utiliser LOAD DATA LOCAL INFILE
--safe-user=create activé, tout utilisateur ne peut pas créer d'autres utilisateurs avec les droits de GRANT, s'il ne dispose pas des droits d'insertion dans la table mysql.user Si vous voulez donner un accès à un utilisateur pour qu'il puisse créer des utilisateurs avec les droits dont il dispose, vous pouvez lui donner les droits suivant : GRANT INSERT(user) ON mysql.user TO 'user'@'hostname'; cela va assurer que l'utilisateur ne peut pas modifier une colonne directement, mais qu'il peut exécuter la commande GRANT sur d'autres utilisateurs.
--secure-auth interdit l'identification pour les comptes qui ont d'anciens mot de passe (ղ.1.1)
--skip-grant-tables force le serveur à ne pas utiliser les tables de droits. Donne tous les droits a tous les utilisateurs.
--skip-name-resolve les nom d'hôtes ne sont pas résolus. toutes les valeurs de la colonne host dans les tables de droits doivent être des adresses ip, ou bien localhost
--skip-networking Ne pas accepter les connexions TCP/IP venant du réseau, mais uniquement via socket Unix.

Problèmes de sécurité avec LOAD DATA LOCAL

   La commande LOAD DATA peut lire des données sur le serveur hôte ou charger un fichier sur le client avec LOCAL.

  Pour le client en ligne de commande mysql, LOAD DATA LOCAL peut être activé en spécifiant l'option --local-infile[=1], ou désactivé avec --local-infile=0.

  Vous pouvez désactiver toutes les commandes LOAD DATA LOCAL du serveur MySQL en démarrant mysqld avec --local-infile=0. Similairement, pour mysqlimport, les options --local et -L activent le chargement distant de fichiers. Dans ce cas, il faut que le serveur accepte aussi cette configuration pour que l'opération fonctionne.

Règles de sécurité et droits d'accès au serveur

Table des droits d-accès
   Lors de la seconde étape du contrôle d'accès (vérification de la requête), le serveur peut, suivant la requête, consulter aussi les tables tables_priv et columns_priv. Les champs de ces tables sont:

Autre tables des droits d-accès
   Chaque table de droit contient des champs d'identification et des champs de droits.

  - Les champs d'identification déterminent quels utilisateurs correspondent à cette ligne dans la table.

  - Les champs de droits indiquent si le droit est donné. Les champs d'identification sont des chaînes:

Champs d-identification
   Dans les tables user, db et host tous les champs de droits sont déclarés avec le type ENUM('N','Y')

  Dans les tables tables_priv et column_priv les champs de droits sont déclarés comme des champs de type SET.

Champs de droits
   Le serveur utilise les tables de droits comme ceci :

- La table user détermine si le serveur accepte ou rejette la connexion. Pour les connexions acceptées, tous les privilèges donnés dans la table user indiquent des privilèges globaux. Ces droits s'appliquent à toutes les bases du serveur.
- Les champs d'identification de la table db déterminent quels utilisateurs peuvent accéder à quelles bases, depuis quel hôte. Les champs de droits indiquent les opérations permises. Les droits s'appliquent alors à toutes les bases du serveur.
- La table host est utilisée comme extension de la table db lorsque vous voulez qu'une ligne de la table db s'applique à plusieurs hôtes dans votre réseau, laissez la colonne host vide dans la table db.
- Les tables tables_priv et columns_priv sont similaires à la table db, mais elles s'appliquent au niveau des tables et des colonnes, plutôt qu'au niveau des tables.

   Notez que les droits d'administration ne sont spécifiés que dans la table user, tout comme FILE.

  Pour voir les droit d'un utilisateur:

  SHOW GRANTS FOR 'bob'@'pc84.example.com';

  Un outil de diagnostique pratique est le script mysqlaccess.

Droits fournis par MySQL

Droit fournits par MySQL
   Les droits de SELECT, INSERT, UPDATE et DELETE vous permettent de faire des opérations sur les lignes qui existent, dans une table existante d'une base.

  La commande SELECT requiert le droit de SELECT uniquement si des lignes sont lues dans une table. Vous pouvez exécuter une commande SELECT même sans aucun droit d'accès à une base de données dans le serveur. Par exemple, vous pourriez utiliser le client mysql comme une simple calculatrice :

  mysql› SELECT 1+1;

  mysql› SELECT PI()*2;

  Le droit de INDEX vous donne le droit de créer et détruire des index de table.

  Le droit de ALTER vous donne le droit de modifier une table avec la commande ALTER TABLE.Les droits de CREATE et DROP vous permettent de créer de nouvelles tables et bases de données, et de les supprimer.

  Le droit de GRANT vous permet de donner les droits que vous possédez à d'autres utilisateurs.

   Le droit de FILE vous donne la possibilité de lire et écrire des fichiers sur le serveur avec les commandes LOAD DATA INFILE et SELECT ... INTO OUTFILE.

  Les autres droits sont utilisés pour les opérations administratives qui sont exécutées par l'utilitaire mysqladmin. La table ci-dessous montre quelle commande est associée à mysqladmin avec un de ces droits :

mysqladmin - commandes autorisées
   La commande reload indique au serveur de relire les tables de droits.

  La commande refresh vide les tables de la mémoire, écrit les données et ferme le fichier de log. flush-privileges est un synonyme de reload. Les autres commandes flush-* effectuent des fonctions similaires à la commande refresh mais sont plus limitées dans leur application, et sont préférables dans certains contextes.

  Par exemple, si vous souhaitez simplement vider les tampons dans le fichier de log, utilisez flush-logs, qui est un meilleur choix que refresh.

  La commande shutdown éteint le serveur.

   La commande processlist affiche les informations sur les threads qui s'exécutent sur le serveur. La commande kill termine un des threads du serveur. Vous pouvez toujours afficher et terminer vos propres threads, mais vous aurez besoin des droits de PROCESS pour afficher les threads, et le droit de SUPER pour terminer ceux qui ont été démarrés par d'autres utilisateurs.

  C'est une bonne idée en général, de ne donner les droits de Grant qu'aux utilisateurs qui en ont besoin, et vous devriez être particulièrement vigilant pour donner certains droits :

- Le droit de GRANT permet aux utilisateurs de donner leurs droits à d'autres utilisateurs. Deux utilisateurs avec des droits différents et celui de GRANT pourront combiner leurs droits respectifs pour gagner un autre niveau d'utilisation du serveur.
- Le droit de ALTER peut être utilisé pour tromper le système en renommant les tables.
- Le droit de FILE peut servir à lire des fichiers accessibles à tous sur le serveur, et les placer dans une base de données. Le contenu pourra alors être lu et manipulé avec SELECT. Cela inclus le contenu de toutes les bases actuellement hébergées sur le serveur !
- Le droit de SHUTDOWN peut conduire au dénis de service, en arrêtant le serveur.
- Le droit de PROCESS permet de voir en texte clair les commandes qui s'exécutent actuellement, et notamment les changements de mot de passe.
- Le droit de SUPER peut être utilisé pour terminer les connexions ou modifier le mode opératoire du serveur.
- Les droits sur la base de données mysql peuvent être utilisés pour changer des mots de passe ou des droits dans la table des droits (Les mots de passe sont stockés chiffrés, ce qui évite que les intrus ne les lisent). S'ils accèdent à un mot de passe dans la table mysql.user, ils pourront l'utiliser pour se connecter au serveur avec cet utilisateur (avec des droits suffisants, le même utilisateur pourra alors remplacer un mot de passe par un autre).

Connexion au serveur MySQL

shell› mysql [-h nom_d_hote] [-u nom_d_utilisateur] [-pvotre_mot_de_passe]
shell› mysql [--host=nom_d_hote] [--user=nom_d_utilisateur] [--password=votre_mot_de_passe]
On peut spécifier les paramètres de connexion dans la section [client] du fichier de configuration my.cnf :
[client]
host=nom_d_hote
user=nom_d'utilisateur
password=votre_mot_de_passe

   Contrôle d'accès, étape 1: Vérification de la connexion

  Votre identité est basée sur 3 informations:

- l'hôte depuis l'endroit où vous vous connectez
- Votre nom d'utilisateur MySQL
- Le mot de passe

   La vérification est réalisée avec les 3 colonnes de la table user [host, user et password]. host peut être un nom d'hôte ou une ip. Pour les ip on peut spécifier le masque:(spécifier une plage)

  GRANT ALL PRIVILEGES ON db.* TO david@'192.58.197.0/255.255.255.0';

  Caractères utilisable pour host: % n'importe quel hôte, ou encore x.y.%

  Pour connaître sous quel utilisateur on est connecté: SELECT CURRENT_USER();

   Contrôle d'accès, étape 2 : Vérification de la requête

  pour chaque requête, le serveur vérifie les droits. Ces droits peuvent provenir des tables user, db, tables_priv, column_priv. les droit sont vérifiés comme suit :

droits globaux
OR (droits de base AND droits d'hôte)
OR droits de table
OR droits de colonne

   On devrait toujours tester les requêtes dans la table de droits, en utilisant l'utilitaire mysqlaccess.

  Lors de la modification de privilèges, les droits GRANT, REVOKE et PASSWORD sont immédiatement pris en compte. Si on modifie les tables de droit manuellement avec INSERT UPDATE etc... on doit exécuter la commande FLUSH PRIVILEGES ou la commande mysqladmin flush-privileges, ou encore mysqladmin reload

  syntaxe pour modifier le mot de passe :

  SET PASSWORD FOR 'abe'@'host_name' = PASSWORD('eagle');

Gestion des comptes utilisateur

   Les noms d'utilisateurs MySQL peuvent avoir jusqu'à 16 caractères. Il y'a 2 manières d'ajouter de nouveaux comptes:

- Utiliser la commande GRANT
- Manipuler la table des droits directement

exemples de syntaxe:
mysql› GRANT ALL PRIVILEGES ON generator.php TO 'monty'@'localhost'
-› IDENTIFIED BY 'un_mot_de_passe' WITH GRANT OPTION ;
mysql› GRANT ALL PRIVILEGES ON generator.php TO 'monty'@'%'
-› IDENTIFIED BY 'un_mot_de_passe' WITH GRANT OPTION ;
mysql› GRANT RELOAD,PROCESS ON generator.php TO 'admin'@'localhost' ;
mysql› GRANT USAGE ON generator.php TO 'dummy'@'localhost' ;
mysql› INSERT INTO user VALUES('localhost','monty',PASSWORD('un_mot_de_passe'),
-› 'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y') ;
mysql› INSERT INTO user VALUES('%','monty',PASSWORD('un_mot_de_passe'),
-› 'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y') ;
mysql› INSERT INTO user SET Host='localhost',User='admin',
-› Reload_priv='Y', Process_priv='Y' ;
mysql› INSERT INTO user (Host,User,Password)
-› VALUES('localhost','dummy','') ;
mysql› FLUSH PRIVILEGES ;
mysql› GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
-› ON bankaccount.*
-› TO custom@localhost
-› IDENTIFIED BY 'stupid' ;
mysql› GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
-› ON expenses.*
-› TO custom@whitehouse.gov
-› IDENTIFIED BY 'stupid' ;
mysql› GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
-› ON customer.*
-› TO custom@'%'
-› IDENTIFIED BY 'stupid' ;
mysql› INSERT INTO user (Host,User,Password)
-› VALUES('localhost','custom',PASSWORD('stupid')) ;
mysql› INSERT INTO user (Host,User,Password)
-› VALUES('server.domain','custom',PASSWORD('stupid')) ;
mysql› INSERT INTO user (Host,User,Password)
-› VALUES('whitehouse.gov','custom',PASSWORD('stupid')) ;
mysql› INSERT INTO db
-› (Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,
-› Create_priv,Drop_priv)
-› VALUES
-› ('localhost','bankaccount','custom','Y','Y','Y','Y','Y','Y') ;
mysql› INSERT INTO db
-› (Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,
-› Create_priv,Drop_priv)
-› VALUES
-› ('whitehouse.gov','expenses','custom','Y','Y','Y','Y','Y','Y') ;
mysql› INSERT INTO db
-› (Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,
-› Create_priv,Drop_priv)
-› VALUES('%','customer','custom','Y','Y','Y','Y','Y','Y') ;
mysql› FLUSH PRIVILEGES ;

Si vous voulez donner un accès spécifique à un utilisateur à partir de n'importe quelle machine d'un domaine donné, vous pouvez utiliser la commande GRANT, en utilisant ‘%’ comme joker dans le nom de l'hôte
mysql› GRANT ...
-› ON generator.php
-› TO monutilisateur@"%.mondomaine.com"
-› IDENTIFIED BY 'monmotdepasse' ;
Pour faire la même chose en modifiant directement la table de droits, faites
mysql› INSERT INTO user VALUES ('%.mondomaine.com', 'monutilisateur',
-› PASSWORD('monmotdepasse'),...) ;
mysql› FLUSH PRIVILEGES ;
Supprimer un compte utilisateur, utiliser la commande
DROP USER

Limiter les ressources utilisateur

- nombre de requêtes par heure
- nombre de modifications par heure
- Nombre de connexions réalisées par heures

Pour configurer et changer les limites d'un compte existant, utiliser la commande GRANT USAGE au niveau global avec ON *.*.
mysql› GRANT USAGE ON generator.php TO 'francis'@'localhost'
-› WITH MAX_QUERIES_PER_HOUR 100 ; ; limite de requêtes à 100
mysql› GRANT USAGE ON generator.php TO 'francis'@'localhost'
-› WITH MAX_CONNECTIONS_PER_HOUR 0 ; ; limite supprimée
Pour remettre à 0 les compteurs pour tous les comptes, faites
FLUSH USER_RESOURCES
puis
FLUSH PRIVILEGES

Configurer les mots de passe

les mots de passe peuvent être assignés avec mysqladmin.
mysqladmin -u user_name -h host_name password "newpasswd"
On peut utiliser SET PASSWORD
SET PASSWORD FRO 'user_name'@'%' = PASSWORD('newpasswd') ;
modifier son propre mot de passe
SET PASSWORD = PASSWORD('newpasswd') ;
On peut utiliser GRANT USAGE au niveau global ON generator.php
GRANT USAGE ON generator.php TO 'user_name'@'%' IDENTIFIED BY 'newpasswd' ;
on peut utiliser la table user directement. Pour établir un mot de passe à la création d'un compte
INSERT INTO user (Host,User,Password) VALUES('%','new_user','newpasswd') ;
FLUSH PRIVILEGES ;
Pour changer le mot de passe d'un compte existant
UPDATE user SET Password = PASSWORD('newpasswd') WHERE Host = '%' AND User = 'user_name' ;
FLUSH PRIVILEGES ;
En utilisant mysqladmin password ou GRANT .....IDENTIFIED BY la fonction PASSWORD() n'est pas nécessaire.
Il est possible de lister les mots de passe dans le groupe [client] de my.cnf. faire un chmod 400 /etc/mysql/my.cnf

Connexions sécurisées

   MySQL n'utilise pas les connexions chiffrées par défaut, car cela ralentit considérablement le protocole de communication. Chiffrer les données est une tâche particulièrement coûteuse, qui peut ralentir considérablement les tâches principales de MySQL.

  Pour utiliser les connexions sécurisées utiliser le script configure avec les options --with-vio et --with-openssl

  Pour vérifier que le serveur supporte les connexions sécurisées utiliser la commande : SHOW VARIABLES LIKE 'have_openssl'

DIR=`pwd`/openssl
PRIV=$DIR/private
mkdir $DIR $PRIV $DIR/newcerts
cp /usr/share/ssl/openssl.cnf $DIR
replace ./demoCA $DIR -- $DIR/openssl.cnf
# Créez les dossiers nécessaires : $database, $serial et $new_certs_dir optionnel
touch $DIR/index.txt
echo "01" › $DIR/serial
# Génération du cerificat d'autorité (CA)
openssl req -new -x509 -keyout $PRIV/cakey.pem -out $DIR/cacert.pem -config $DIR/openssl.cnf
# Création des clé et requêtes serveur
openssl req -new -keyout $DIR/server-key.pem -out $DIR/server-req.pem -days 3600 -config $DIR/openssl.cnf
# Supprimez la passe-phrase de la clé (optionnel)
openssl rsa -in $DIR/server-key.pem -out $DIR/server-key.pem
# Signez le certificat serveur
openssl ca -policy policy_anything -out $DIR/server-cert.pem -config $DIR/openssl.cnf -infiles $DIR/server-req.pem
# Créez les clé et requêtes client
openssl req -new -keyout $DIR/client-key.pem -out $DIR/client-req.pem -days 3600 -config $DIR/openssl.cnf
# Supprimez la passe-phrase de la clé (optionnel)
openssl rsa -in $DIR/client-key.pem -out $DIR/client-key.pem
# Signez le certificat client
openssl ca -policy policy_anything -out $DIR/client-cert.pem -config $DIR/openssl.cnf -infiles $DIR/client-req.pem
# Créez le fichier my.cnf que vous pourrez utiliser pour tester les différents certificats
cnf=""
cnf="$cnf [client]"
cnf="$cnf ssl-ca=$DIR/cacert.pem"
cnf="$cnf ssl-cert=$DIR/client-cert.pem"
cnf="$cnf ssl-key=$DIR/client-key.pem"
cnf="$cnf [mysqld]"
cnf="$cnf ssl-ca=$DIR/cacert.pem"
cnf="$cnf ssl-cert=$DIR/server-cert.pem"
cnf="$cnf ssl-key=$DIR/server-key.pem"
echo $cnf | replace " " '
' › $DIR/my.cnf
# To test MySQL
mysqld --defaults-file=$DIR/my.cnf &
mysql --defaults-file=$DIR/my.cnf
pour tester les connexions SSL, lancez le serveur comme ceci :
mysqld --default-file=/path/to/my.cnf &
puis lancer le programme client en utilisant le même fichier d'options :
mysql --defaults-file=/path/to/my.cnf

Options de GRANT avec SSL

MySQL peut vérifier les certificats X509 en plus de la combinaison habituelle de nom d'utilisateur et mot de passe.
Différentes possibilités pour limiter les connexions:

l'option REQUIRE SSL requière que les connexions soient chiffrées avec SSL
mysql› GRANT ALL PRIVILEGES ON test.* TO root@localhost
-› IDENTIFIED BY "goodsecret" REQUIRE SSL ;
REQUIRE X509 impose au client d'avoir un certificat valide, mais le certificat lui même importe peu, la seul restriction est qu'il doit être possible de vérifier la signature avec une autorité de certification.
mysql› GRANT ALL PRIVILEGES ON test.* TO root@localhost
-› IDENTIFIED BY "goodsecret" REQUIRE X509 ;
REQUIRE ISSUER “issuer” restreint les tentatives de connexions : le client doit se présenter avec un certificat X509 valide, émit par l'autorité de certification “issuer”. Utiliser un certificat x509 implique obligatoirement des chiffrements, donc l'option SSL est sous entendue.
mysql› GRANT ALL PRIVILEGES ON test.* TO root@localhost
-› IDENTIFIED BY "goodsecret"
-› REQUIRE ISSUER "C=FI, ST=Some-State, L=Helsinki,
"› O=MySQL Finland AB, CN=Tonu Samuel/Email=tonu@mysql.com" ;
REQUIRE SUBJECT “subject” impose au client d'avoir un certificat X509 valide avec le sujet “subject”
mysql› GRANT ALL PRIVILEGES ON test.* TO root@localhost
-› IDENTIFIED BY "goodsecret"
-› REQUIRE SUBJECT "C=EE, ST=Some-State, L=Tallinn,
"› O=MySQL demo client certificate,
"› CN=Tonu Samuel/Email=tonu@mysql.com" ;
REQUIRE CIPHER “cipher” est utilisé pour s'assurer que les chiffrements sont suffisamment robuste, et que la bonne longueur de la clé est utilisée.
mysql› GRANT ALL PRIVILEGES ON test.* TO root@localhost
-› IDENTIFIED BY "goodsecret"
-› REQUIRE CIPHER "EDH-RSA-DES-CBC3-SHA" ;
Les options SUBJECT, ISSUER et CIPHER peuvent être combinées :
mysql› GRANT ALL PRIVILEGES ON test.* TO root@localhost
-› IDENTIFIED BY "goodsecret"
-› REQUIRE SUBJECT "C=EE, ST=Some-State, L=Tallinn,
"› O=MySQL demo client certificate,
"› CN=Tonu Samuel/Email=tonu@mysql.com"
-› AND ISSUER "C=FI, ST=Some-State, L=Helsinki,
"› O=MySQL Finland AB, CN=Tonu Samuel/Email=tonu@mysql.com"
-› AND CIPHER "EDH-RSA-DES-CBC3-SHA" ;

Options SSL en ligne de commande

--ssl indique que le serveur autorise les connexions SSL, on doit spécifier également les options –ssl-ca ,–ssl-cert et –ssl-key
--ssl-ca=file_name chemin vers le fichier avec une liste des autorités de certifications SSL connus
--ssl-capath=directory_name le chemin où se trouve les certificats SSL au format PEM
--ssl-cipher=file_name nom du fichier de certificat SSL à utiliser pour établir une connexion sécurisée.
--ssl-cipher=cipher_list liste de chiffrements autorisées, à utiliser avec SSL a le même format que la commande openssl ciphers.
--ssl-key=file_name nom du fichier de la clé SSL à utiliser pour établir une connexion sécurisée.

Prévention des désastres et restauration

   Pour sauvegarder des bases de données:

  Faire un LOCK TABLES sur les tables concernées, suivi d'un FLUSH TABLES pour celles-ci. On a besoin que d'un verrou en lecture, cela permet aux autres threads de continuer à effectuer des requêtes sur les tables dont on fait la copie des fichiers. FLUSH TABLES est requis pour s'assurer que toutes les pages d'index actifs soient écrits sur le disque avant de commencer la sauvegarde.

  Pour faire une sauvegarde d'une table SQL, il suffit d'utiliser SELECT INTO OUTFILE ou BACKUP TABLE. On peut utiliser aussi mysqldump ou le script mysqlhotcopy.

Effectuer une sauvegarde complète de la base de données:
mysqldump –tab=/path/to/backup –opt –all
ou
mysqlhotcopy base /path/to/backup

   Arrêtez mysqld et le redémarrer avec l'option –log-update[=nom-fichier]. Les fichiers de log fournissent les informations dont vous avez besoin pour répliquer les modifications de la base de données qui sont subséquents au moment où vous avez utilisé mysqldump.

  Si votre serveur MySQL est un esclave, quelque soit la sauvegarde que vous utilisez, lorsque vous sauvez vos données sur votre esclave, vous devez aussi sauver les fichiers master.info et relay-log.info, qui sont nécessaires pour relancer la réplication après la restauration des données de l'esclave. Si votre esclave doit traiter des commandes LOAD DATA INFILE, vous devez aussi sauver les fichiers nommés SQL_LOAD-*, qui sont dans le dossier spécifié par --slave-load-tmpdir. Ce dossier vaut par défaut la valeur de la variable tmpdir, si elle n'est pas spécifiée. L'esclave aura besoin de ces fichiers pour relancer la réplication d'une opération LOAD DATA INFILE interrompue.

   Si vous avez besoin de restaurer quelque chose, essayez d'abord de restaurer vos tables avec REPAIR TABLE ou myisamchk -r en premier. Cela devrait fonctionner dans 99.9% des cas. Si myisamchk ne réussi pas, essayez la procédure suivante (cela ne fonctionnera que si vous avez démarré MySQL avec --log-update:

Restaurez la sauvegarde originale de mysqldump.
Exécutez la commande suivante pour remettre en marche les mises à jour dans le log binaire:
shell› mysqlbinlog hostname-bin.[0-9]* | mysql

Politique de sauvegarde

   Faire une sauvegarde de toutes les tables InnoDB dans toutes les bases:

  shell› mysqldump --single-transaction --all-databases › backup_sunday_1_PM.sql

  Le fichier .sql résultant, produit par mysqldump contient les commandes SQL INSERT qui peuvent être utilisées pour recharger les tables ultérieurement.

   Pour effectuer des sauvegarde incrémentales, le serveur doit être lancé avec l'option --log-bin pour qu'il puisse stocker ces modifications au fur et à mesure des modifications des données. Cette option active le log binaire, ce qui fait que chaque commande qui modifie les données est enregistré dans un fichier appelé log binaire. A chaque fois que le serveur redémarre, MySQL créer un nouveau fichier de log binaire, en utilisant le numéro de séquence suivant.

  Lorsque le serveur fonctionne on peut aussi lui dire de clore le fichier log et d'en ouvrir un nouveau avec la commande SQL FLUSH LOGS ou bien avec mysqladmin flush-logs. La commande mysqldump dispose aussi d'une option pour clore les fichiers de logs. Le fichier .index contient la liste de tous les fichiers de logs binaire du dossier de données. Ce fichier est utilisé durant les opérations de réplication.

utiliser mysqldump pour qu'il referme les logs binaires lors de la sauvegarde complète, et que le fichier de sauvegarde contienne les noms des nouveaux fichiers de logs
shell› mysqldump --single-transaction --flush-logs --master-data=2 --all-databases › blackup_sunday_1_PM.sql
pour supprimer les logs anciens, par exemple ceux qui sont antérieurs à la sauvegarde complète :
shell› mysqldump --single-transaction --flush-logs --master-data=2 --all-databases --delete-master-logs › backup_sunday_1_PM.sql

   Noter que la commande est dangereuse si le serveur est un maitre réplicateur car les esclaves pourraient ne pas avoir traité le contenu des logs binaires. La description de la commande PURGE MASTER LOGS explique ce qui doit être vérifié avant d'effacer un fichier de log binaire.

Utiliser les sauvegardes pour la restauration:
shell› mysql ‹ blachup_sunday_1_PM.sql
pour utiliser les sauvegardes incrémentales:
shell› mysqlbinlog mysqld-bin.000007 mysqld-bin.000008 | mysql
Il reste la dernière sauvegarde, qui est le dernier fichier de log binaire. de préférence spécifier un chemin vers un volume sécurisé pour l'option --log-bin.

Fichiers de log de MySQL

Le log d'erreurs Problèmes rencontrés lors du démarrage, de l'exécution ou de l'arrêt de mysqld.
Le log ISAM Garde une trace des changements liés au tables ISAM. Utilisé uniquement pour déboguer le code ISAM.
Le log de requêtes Connexions établies et requêtes exécutées.
Le log de mises à jour Désapprouvé : Enregistre toutes les commandes qui changent les données.
Le log binaire Enregistre toutes les commandes qui changent quelque chose. Utilisé pour la réplication.
Le log des requêtes lentes Enregistre toutes les requêtes qui ont pris plus de long_query_time à s'exécuter ou celles qui n'ont pas utilisé d'index.

   Par défaut, tous les fichiers de log peuvent être trouvés dans le dossier de données de mysqld.On peut forcer mysqld à rouvrir les fichiers de log ou à passer à un nouveau log en exécutant FLUSH LOGS.

  Le log d'erreurs: Contiennent les informations indiquant quand mysqld a été lancé ou arrêté, ainsi que les erreurs critiques. si mysqld s'arrête inopinément -› restarted mysqld. Si mysqld remarque une table à réparer/analyser, il l'écrit également.

  Pour spécifier l'emplacement du log d'erreur: --log-error[=file_name]. Sans cette option, écrit sur la sortie standard.

  Pour démarrer le log général de requêtes: --log[=fichier] (par défaut nommé 'hostname'.log)

  Pour démarrer le log des requêtes lentes: --log-slow-queries[=file_name]. Toutes les requêtes plus longues que long_query_time secondes à s'exécuter. Le temps d'acquisition d'un verrou n'est par compté. Pour obtenir un sommaire des requêtes lentes, utiliser mysqldumpslow.

Entretient des fichier de log

   mysql-log-rotate permet de gérer les logs. attention au logs pour la réplication.Pour forcer Mysql à utiliser de nouveaux fichiers de log: mysqladmin flush-logs ou FLUSH-LOGS.

  flush-logs permet de fermer les logs puis les rouvre, donc il faut les déplacer avant.

Multiples serveurs sur une seule machine

au minimum, les options suivantes doivent être différentes sur chaque serveur:
--port=port_num port d'écoute TCP
--socket=path chemin du socket
--pid-file=path chemin du fichier PID
Les options suivantes, si utilisées, doivent être différentes pour chaque serveur:
--log=path
--log-bin=path
--log-update=path
--log-error=path
--log-isam=path
--bdb-logdir=path
Pour de meilleurs performances, on pour également spécifier les options suivantes, pour répartir la charge entre plusieurs disques physiques

--tmpdir=path
--bdb-tmpdir=path
Également, le dossier de données:

--datadir=path
En cas de plusieurs installations de MySQL à différents endroits, utiliser:

--base-dir=path
Pour spécifier de fichier d'option à utiliser:

--defauts-file

Pour lancer un serveur avec son fichier d'option
shell› mysqld --defaults-file=C :\my-opts1.cnf
pour l'éteindre
shell› mysqladmin --port=3307 shutdown
On peut compiler mysql avec différents port et socket pour chacun avec
./configure --with-tcp-port=port_number --with-unix-socket-path=file_name --prefix=/usr/local/mysql-4.0.17
Connaître les caractéristiques d'un serveur
mysqladmin --host=host_name --port=port_number variables
Pour lancer un serveur sans l'avoir compilé avec des valeurs par défaut
/path/to/mysqld_safe --socket=file_name --port=port_number
Pour utiliser un dossier de données différent, utiliser l'option
--datadir=path à mysqld_safe
Idem, en utilisant les variables d'environnement pour spécifier le nom du socket et le port
shell› MYSQL_UNIX_PORT=/tmp/mysqld-new.sock
shell› MYSQL_TCP_PORT=3307
shell› export MYSQL_UNIX_PORT MYSQL_TCP_PORT
shell› scripts/mysql_install_db
shell› bin/mysqld_safe &
^
04 mai 2010

htmlpdflatexmanmd




MySQL - gestion du cache

MySQL - gestion du cache

Gestion du cache MySQL

   C'est une méthode rapide pour lancer un second serveur pour le tester. Le plus agréable de cette méthode est que les variables d'environnement vont être adoptées par les logiciels clients que vous invoquerez avec le même Shell. Par conséquent, les connexions seront automatiquement dirigées vers le nouveau serveur. Pour les scripts de démarrage, la commande doit être :

  mysqld_safe --defaults-file=path-to-option-file

Cache de requêtes MySQL

   MySQL server bénéficie d'un cache de requêtes. En fait, le cache sauvegarde le texte d'une requête SELECT avec le résultat qui a été envoyé au client. Si une requête identique est appelée par la suite, le serveur retournera le résultat à partir du cache plutôt que d'analyser puis exécuter la requête à nouveau.

  Le cache de requêtes est extrêmement utile dans un environnement où les tables ne changent pas souvent, et que vous avez de nombreuses requêtes identiques. C'est la situation classique des serveurs Web, qui génèrent beaucoup de pages dynamiques à partir du même contenu.

  Note : Le cache de requêtes ne retourne pas de données périmées. À chaque fois que les données sont modifiées, les entrées correspondantes dans le cache sont effacées.

   Si vous ne voulez pas utiliser le cache de requêtes paramétrez query_cache_size à zéro. En désactivant le cache de requête, il n'y a aucune surcharge apparente. (le cache de requêtes peut être désactivé à l'aide de l'option de configuration --without-query-cache)

Fonctionnement du cache de requêtes

Les requêtes sont comparées avant analyse, donc ces 2 requêtes sont considérées comme différentes:
SELECT * FROM tbl_name
Select * from tbl_name

   Les requêtes qui utilisent différentes bases de données, différents protocoles ou différents jeux de caractères sont alors considérés comme différentes.

  Si un résultat de requête a été retourné depuis le cache de requête, la variable Com_select ne sera pas incrémenté, mais Qchache_hits le sera.

  Si une table change, toutes les requêtes mise en cache qui utilisaient cette table sont retirés.

  Une requête ne peut être mise en cache si elle contient l'une des fonctions suivantes:

fonctions non mises en cache
   Une requête ne sera pas mise en cache dans ces conditions:

- Elle contient des fonctions définies par l'utilisateur : UDF.
- Elle contient des variables utilisateur.
- Elle fait référence à des tables de la base mysql.
- Elle est de l'une des formes suivantes:
- SELECT ... IN SHARE MODE
- SELECT ... INTO OUTFILE ...
- SELECT ... INTO DUMPFILE ...
- SELECT * FROM ... WHERE autoincrement_col IS NULL
- La dernière forme n'est pas mise en cache, car elle est utilisée comme palliatif pour ODBC, afin d'obtenir la dernière valeur insérée.
- Elle utilise une table TEMPORARY.
- Elle n'utilise pas de tables.
- L'utilisateur a un droit de niveau colonne pour l'une des tables impliquée.
- Avant la lecture de la requête dans le cache de requête, MySQL vérifie que l'utilisateur a les droits SELECT pour toutes les bases de données impliquées. Si ce n'est pas le cas, le résultat n'est pas utilisé.

Options relatives au cache de requêtes utilisés dans une requête SELECT
SQL_CACHE Le résultat de la requête est en cache si la valeur de la variable query_cache est à ON ou DEMAND
SQL_NO_CACHE Le résultat de la requête n'est pas mis en cache

Exemples

SELECT SQL_CACHE id, name FROM customer ;
SELECT SQL_NO_CACHE id, name FROM customer ;

Configuration du cache de requêtes

   Pour configurer la taille du cache, modifier la variable query_cache_size. Une valeur de 0 désactive le cache.

  L'allocation de mémoire pour le cache se fait en bloc à mesure des besoin, c'est couteux en temps, pour définir une taille de bloc modifier query_cache_min_res_unit (défaut: 4ko). Le nombre de blocks libres et de requêtes supprimées pour libérer de la place sont stockées dans le variables Qcache_free_blocks et Qcache_lowmem_prunes

  Chaque requête a besoin au minimum de 2 blocs, un pour le texte de la requête et un autre, ou plus, pour le résultat. De même chaque table utilisée par une ou plusieurs requêtes a besoin d'un bloc.

        query_cache_type modifie son comportement:
        0, OFF Empêche la mise en cache ou la lecture de résultat en cache
        1, ON Permet le cache, sauf SELECT SQL_NO_CACHE
        2, DEMAND met tout en cache

Pour savoir si le cache est actif:
SHOW VARIABLES LIKE 'have_query_cache' ;
Pour désactiver le cache pour une session
SET SESSION query_cache_type=OFF
Pour défragmenter le cache de requêtes
FLUSH QUERY CACHE
et
FLUSH TABLE
Pour visualiser les performances du cache
SHOW STATUS LIKE 'Qcache%';
Le nombre total de commandes SELECT vaut
Com_select + Qcache_hits + requêtes avec une erreur
La valeur de Com_select est
qcache_inserts + qcache_not_cached + erreurs de droits d'accès ou de colonnes
^
04 mai 2010

htmlpdflatexmanmd




MySQL - Le langage

MySQL - Le langage

Description du langage MySQL

Chaînes

   Si le serveur est en mode ANSI_QUOTES, les chaînes ne peuvent être mises qu'entre guillemets simples

\0 un 0 ASCII(NUL)
\' guillemet simple
\" guillemet double
\b effacement
\n nouvelle ligne
\r retour chariot
\t tabulation
\z ASCII(26)(Control-Z) Peut être encodé pour éviter des problèmes avec windows, puisqu'il équivaut à une fin de fichier
\\ un anti-slash
\% un signe pourcentage littéral
\_ Un signe souligné littéral

   Si vous voulez insérer des données binaires dans un champ chaîne (comme un BLOB), les caractères suivants doivent être échappés:

NUL ASCII 0
\ ASCII 92
' ASCII 39
" ASCII 34

Les nombres

Valeurs hexadécimales:
mysql› SELECT x'4D7953514C';
-› 'MySQL'
mysql› SELECT 0xa+0;
-› 10
mysql› SELECT 0x5061756c;
-› 'Paul'
mysql› SELECT 0x41, CAST(0x41 AS UNSIGNED);
-› 'A', 65
mysql› SELECT HEX('cat');
-› '636174'
mysql› SELECT 0x636174;
-› 'cat'
Valeurs booléennes:
TRUE vaut 1 et FALSE vaut 0
champs de bits:
mysql› CREATE TABLE t (b BIT(8));
mysql› INSERT INTO t SET b = b'11111111';
mysql› INSERT INTO t SET b = b'1010';

   Valeurs NULL : signifie "pas de données" et est différent des valeurs comme 0 ou des chaînes vides

Noms de bases, tables, index, colonnes et alias

   limité a 64 octets(255 pour les alias). les identifiants sont stockés en utf8 et peuvent être entre guillemets

caractères de protection pour les identifiants contenant des caractères spéciaux ou sont un mot réservé :
`
mysql› SELECT * FROM `select` WHERE `select`.id › 100;
identifiants. Pour faire référence à une colonne:
col_name
tbl_name.col_name
db_name.tbl_name.col_name
commentaires:
# ceci est un commentaire
— ceci est un commentaire
/* ceci
est un
commentaire */

Mots clé réservés


ADD_________________ALL_______________ALTER
ANALYZE_____________AND_______________AS
ASC_________________ASENSITIVE________BEFORE
BETWEEN_____________BIGINT____________BINARY
BLOB________________BOTH______________BY
CALL________________CASCADE___________CASE
CHANGE______________CHAR______________CHARACTER
CHECK_______________COLLATE___________COLUMN
CONDITION___________CONSTRAINT________CONTINUE
CONVERT_____________CREATE____________CROSS
CURRENT_DATE________CURRENT_TIME______CURRENT_TIMESTAMP
CURRENT_USER________CURSOR____________DATABASE
DATABASES___________DAY_HOUR__________DAY_MICROSECOND
DAY_MINUTE__________DAY_SECOND________DEC
DECIMAL_____________DECLARE___________DEFAULT
DELAYED_____________DELETE____________DESC
DESCRIBE____________DETERMINISTIC_____DISTINCT
DISTINCTROW_________DIV_______________DOUBLE
DROP________________DUAL______________EACH
ELSE________________ELSEIF____________ENCLOSED
ESCAPED_____________EXISTS____________EXIT
EXPLAIN_____________FALSE_____________FETCH
FLOAT_______________FLOAT4____________FLOAT8
FOR_________________FORCE_____________FOREIGN
FROM________________FULLTEXT__________GRANT
GROUP_______________HAVING____________HIGH_PRIORITY
HOUR_MICROSECOND____HOUR_MINUTE_______HOUR_SECOND
IF__________________IGNORE____________IN
INDEX_______________INFILE____________INNER
INOUT_______________INSENSITIVE_______INSERT
INT_________________INT1______________INT2
INT3________________INT4______________INT8
INTEGER_____________INTERVAL__________INTO
IS__________________ITERATE___________JOIN
KEY_________________KEYS______________KILL
LEADING_____________LEAVE_____________LEFT
LIKE________________LIMIT_____________LINES
LOAD________________LOCALTIME_________LOCALTIMESTAMP
LOCK________________LONG______________LONGBLOB
LONGTEXT____________LOOP______________LOW_PRIORITY
MATCH_______________MEDIUMBLOB________MEDIUMINT
MEDIUMTEXT__________MIDDLEINT_________MINUTE_MICROSECOND
MINUTE_SECOND_______MOD_______________MODIFIES
NATURAL_____________NOT_______________NO_WRITE_TO_BINLOG
NULL________________NUMERIC___________ON
OPTIMIZE____________OPTION____________OPTIONALLY
OR__________________ORDER_____________OUT
OUTER_______________OUTFILE___________PRECISION
PRIMARY_____________PROCEDURE_________PURGE
READ________________READS_____________REAL
REFERENCES__________REGEXP____________RELEASE
RENAME______________REPEAT____________REPLACE
REQUIRE_____________RESTRICT__________RETURN
REVOKE______________RIGHT_____________RLIKE
SCHEMA______________SCHEMAS___________SECOND_MICROSECOND
SELECT______________SENSITIVE_________SEPARATOR
SET_________________SHOW______________SMALLINT
SONAME______________SPATIAL___________SPECIFIC
SQL_________________SQLEXCEPTION______SQLSTATE
SQLWARNING__________SQL_BIG_RESULT____SQL_CALC_FOUND_ROWS
SQL_SMALL_RESULT____SSL_______________STARTING
STRAIGHT_JOIN_______TABLE_____________TERMINATED
THEN________________TINYBLOB__________TINYINT
TINYTEXT____________TO________________TRAILING
TRIGGER_____________TRUE______________UNDO
UNION_______________UNIQUE____________UNLOCK
UNSIGNED____________UPDATE____________USAGE
USE_________________USING_____________UTC_DATE
UTC_TIME____________UTC_TIMESTAMP_____VALUES
VARBINARY___________VARCHAR___________VARCHARACTER
VARYING_____________WHEN______________WHERE
WHILE_______________WITH______________WRITE
XOR_________________YEAR_MONTH________ZEROFILL

   Voici de nouveaux mots réservés en MySQL 5.0:


ASENSITIVE__________CALL______________CONDITION
CONTINUE____________CURSOR____________DECLARE
DETERMINISTIC_______EACH______________ELSEIF
EXIT________________FETCH_____________INOUT
INSENSITIVE_________ITERATE___________LEAVE
LOOP________________MODIFIES__________OUT
READS_______________RELEASE___________REPEAT
RETURN______________SCHEMA____________SCHEMAS
SENSITIVE___________SPECIFIC__________SQL
SQLEXCEPTION________SQLSTATE__________SQLWARNING
TRIGGER_____________UNDO______________WHILE

Types de colonnes - numériques

- si vous spécifiez l'option ZEROFILL pour une valeur numérique, mysql ajoute automatiquement l'attribut UNSIGNED à la colonne.
TINYINT[(M)] [UNSIGNED] [ZEROFILL] Un très petit entier. L'intervalle de validité pour les entiers signés est de -128 à 127. L'intervalle de validité pour les entiers non-signés est 0 à 255.
BIT, BOOL, BOOLEAN Ce sont des synonymes de TINYINT(1). Un type booléen complet, qui sera introduit pour être en accord avec la norme SQL-99.
SMALLINT[(M)] [UNSIGNED] [ZEROFILL] Un petit entier. L'intervalle de validité pour les entiers signés est de -32768 à 32767. L'intervalle de validité pour les entiers non-signés est 0 à 65535.
MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] Un entier. L'intervalle de validité pour les entiers signés est de -8388608 à 8388607. L'intervalle de validité pour les entiers non-signés est 0 à 16777215.
INT[(M)] [UNSIGNED] [ZEROFILL] Un grand entier. L'intervalle de validité pour les entiers signés est de -2147483648 à 2147483647. L'intervalle de validité pour les entiers non-signés est 0 à 4294967295.
INTEGER[(M)] [UNSIGNED] [ZEROFILL] Synonyme INT.
BIGINT[(M)] [UNSIGNED] [ZEROFILL] Un très grand entier. L'intervalle de validité pour les entiers signés est de -9223372036854775808 à 9223372036854775807. L'intervalle de validité pour les entiers non-signés est 0 à 18446744073709551615.

   Quelques conseils à suivre avec les colonnes de type BIGINT:

- Tous les calculs arithmétiques sont fait en utilisant des BIGINT signés ou des valeurs DOUBLE. Il est donc recommandé de ne pas utiliser de grands entiers non-signés dont la taille dépasse 9223372036854775807 (63 bits), hormis avec les fonctions sur les bits! Si vous faîtes cela, les derniers chiffres du résultats risquent d'être faux, à cause des erreurs d'arrondis lors de la conversion de BIGINT en DOUBLE.
MySQL peut gérer des BIGINT dans les cas suivants:
- Utiliser des entiers pour stocker des grandes valeurs entières non signées, dans une colonne de type BIGINT.
- Avec MIN(big_int_column) et MAX(big_int_column).
- Avec les opérateurs (+, -, *, etc.) où tous les opérandes sont des entiers.
- Vous pouvez toujours stocker une valeur entière exacte BIGINT dans une colonne de type chaîne. Dans ce cas, MySQL fera des conversions chaîne / nombre, qui n'utilisera pas de représentation intermédiaire en nombre réels.

   ‘-’, ‘+’ et ‘*’ utiliseront l'arithmétique entière des BIGINT lorsque les deux arguments sont des entiers. Cela signifie que si vous multipliez deux entiers (ou des résultats de fonctions qui retournent des entiers), vous pourriez rencontrer des résultats inattendus lorsque le résultat est plus grand que 9223372036854775807.

FLOAT(precision) [UNSIGNED] [ZEROFILL] Un nombre à virgule flottante. précision peut valoir ‹=24 pour une précision simple, et entre 25 et 53 pour une précision double. Ces types sont identiques aux types FLOAT et DOUBLE, décrit ci-dessous. FLOAT(X) a le même intervalle de validité que FLOAT et DOUBLE, mais la taille d'affichage et le nombre de décimales est indéfini.

   En MySQL version 3.23, c'est un véritable nombre à virgule flottante. Dans les versions antérieures, FLOAT(precision) avait toujours 2 décimales. Notez qu'utiliser FLOAT peut vous donner des résultats inattendus, car tous les calculs de MySQL sont fait en double précision. Cette syntaxe est fournie pour assurer la compatibilité avec ODBC. Utiliser des FLOAT peut vous donner des résultats inattendus, car les calculs sont fait en précision double.

FLOAT[(M,D)] [UNSIGNED] [ZEROFILL] Un petit nombre à virgule flottante, en précision simple. Les valeurs possibles vont de -3.402823466E+38 à -1.175494351E-38, 0, et 1.175494351E-38 à 3.402823466E+38. Si UNSIGNED est spécifié, les valeurs négatives sont interdites. L'attribut M indique la taille de l'affichage, et D est le nombre de décimales. FLOAT sans argument et FLOAT(X) (où X est dans l'intervalle 0 à 24) représente les nombres à virgule flottante en précision simple.
DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL] Un nombre à virgule flottante, en précision double. Les valeurs possibles vont de -1.7976931348623157E+308 à -2.2250738585072014E-308, 0, et 2.2250738585072014E-308 à 1.7976931348623157E+308. Si UNSIGNED est spécifié, les valeurs négatives sont interdites. L'attribut M indique la taille de l'affichage, et D est le nombre de décimales. DOUBLE sans argument et FLOAT(X) (où X est dans l'intervale 25 to 53) représente les nombres à virgule flottante en précision double.
DOUBLE PRECISION[(M,D)] [UNSIGNED] [ZEROFILL], REAL[(M,D)] [UNSIGNED] [ZEROFILL] Ce sont des synonymes pour DOUBLE. Exception : si le serveur SQL utilise l'option REAL_AS_FLOAT, REAL est alors un synonyme de FLOAT plutôt que DOUBLE.
DECIMAL[(M[,D])] [UNSIGNED] [ZEROFILL] Un nombre à virgule flottante littéral. Il se comporte comme une colonne de type CHAR : "littéral" ("unpacked") signifie que le nombre est stocké sous forme de chaîne : chaque caractère représente un chiffre. La virgule décimale et le signe moins ‘-’ des nombres négatifs ne sont pas comptés dans M (mais de l'espace leur est réservé). Si D vaut 0, les valeurs n'auront pas de virgule décimale ou de partie décimale. L'intervale de validité du type DECIMAL est le même que DOUBLE, mais le vrai intervalle de validité de DECIMAL peut être restreint par le choix de la valeur de M et D. Si UNSIGNED est spécifié, les valeurs négatives sont interdites. Si D est omis, la valeur par défaut est 0. Si M est omis, la valeur par défaut est 10.
DEC[(M[,D])] [UNSIGNED] [ZEROFILL], NUMERIC[(M[,D])] [UNSIGNED] [ZEROFILL], FIXED[(M[,D])] [UNSIGNED] [ZEROFILL] Ce sont des synonymes pour DECIMAL

Types de colonnes - dates et heures

DATE Une date. L'intervalle supporté va de '1000-01-01' à '9999-12-31'. MySQL affiche les valeurs de type DATE au format 'YYYY-MM-DD', mais vous permet d'assigner des valeurs DATE en utilisant plusieurs formats de chaînes et nombres.
DATETIME Une combinaison de date et heure. L'intervalle de validité va de '1000-01-01 00:00:00' à '9999-12-31 23:59:59'. MySQL affiche les valeurs de type DATE au format 'YYYY-MM-DD HH:MM:SS', mais vous permet d'assigner des valeurs DATE en utilisant plusieurs formats de chaînes et nombres.
TIMESTAMP[(M)] Un timestamp. L'intervalle de validité va de '1970-01-01 00:00:00' à quelque part durant l'année 2037. les valeurs TIMESTAMP sont affichées au format YYYYMMDDHHMMSS, YYMMDDHHMMSS, YYYYMMDD ou YYMMDD, suivant que la valeur de M est 14 (ou absente), 12, 8 ou 6, respectivement, mais vous permet d'assigner des valeurs aux colonnes TIMESTAMP en utilisant des nombres ou des chaînes. TIMESTAMP est retournée comme une chaîne, au format 'YYYY-MM-DD HH:MM:SS'. Si vous voulez que MySQL vous retourne un nombre, ajoutez +0 à la colonne. Les différentes tailles de timestamp ne sont pas supportées.

   Une colonne TIMESTAMP est utile pour enregistrer les dates et heures des opérations INSERT et UPDATE, car elle prend automatiquement date actuellement si vous ne lui assignez pas de valeur par vous-même. Vous pouvez aussi lui donner la valeur courante en lui donnant la valeur NULL. L'argument M affecte l'affichage des colonnes de type TIMESTAMP. ses valeurs sont toujours stockées sur 4 octets. Notez que les colonnes TIMESTAMP(M) où M vaut 8 ou 14 sont indiquée comme étant des nombres, alors que les colonnes TIMESTAMP(M) sont indiquées comme étant des chaînes. Cela est fait pour s'assurer que l'ont peut enregistrer et lire correctement les tables ayant ce type.

TIME Une heure. L'intervalle va de '-838:59:59' à '838:59:59'. MySQL affiche les valeurs TIME au format 'HH:MM:SS', mais vous permet d'assigner des valeurs TIME en utilisant des nombres ou des chaînes.
YEAR[(2|4)] Une année, au format 2 ou 4 chiffres (par défaut, c'est 4 chiffres). Les valeurs possibles vont de 1901 à 2155 plus 0000 pour le format à 4 chiffres, et de 1970 à 2069 si vous utilisez le format à 2 chiffres. MySQL affiche les valeurs YEAR au format YYYY mais vous permet d'assigner des valeurs en utilisant des nombres ou des chaînes.

Types de colonnes - chaînes

CHAR et VARCHAR Les types CHAR et VARCHAR sont similaires, mais diffèrent dans la manière dont ils sont stockés et récupérés.

   La longueur d'une colonne CHAR est fixée à la longueur que vous avez défini lors de la création de la table. La longueur peut être n'importe quelle valeur entre 1 et 255. Quand une valeur CHAR est enregistrée, elle est complété à droite avec des espaces jusqu'à atteindre la valeur fixée. Quand une valeur de CHAR est lue, les espaces en trop sont retirés.

   Les valeurs contenues dans les colonnes de type VARCHAR sont de tailles variables. Vous pouvez déclarer une colonne VARCHAR pour que sa taille soit comprise entre 1 et 255, exactement comme pour les colonnes CHAR. Par contre, contrairement à CHAR, les valeurs de VARCHAR sont stockées en utilisant autant de caractères que nécessaire, plus un octet pour mémoriser la longueur. Les valeurs ne sont pas complétées. Au contraire, les espaces finaux sont supprimés avant stockage. Si vous assignez une chaîne de caractères qui dépasse la capacité de la colonne CHAR ou VARCHAR, celle ci est tronquée jusqu'à la taille maximale du champ.

   Les valeurs dans les colonnes CHAR et VARCHAR sont classées et comparées sans tenir compte de la casse, à moins que l'attribut BINARY n'ai été spécifié lors de la création de la table. L'attribut BINARY signifie que les valeurs sont classées et triées en tenant compte de la casse, suivant l'ordre des caractères ASCII de la machine ou est installé le serveur MySQL. BINARY n'affecte pas les méthodes de lecture et de stockage des valeurs. L'attribut BINARY se propage dans une expression : il suffit qu'une seule colonne, utilisée dans une expression, ait l'attribut BINARY pour que toute l'expression ne tienne plus compte de la casse.

BINARY et VARBINARY Les types BINARY et VARBINARY sont similaires à CHAR et VARCHAR, hormis le fait qu'ils contiennent des chaînes binaires, plutôt que des chaînes de texte. C'est à dire, qu'ils contiennent des chaînes d'octets, plutôt que des chaînes de caractères. Cela signifie qu'ils n'ont pas de jeu de caractères associé, et les tris et comparaisons sont basées sur la valeur numérique de l'octet. La taille maximale pour les types BINARY et VARBINARY, est la même que celles de CHAR et VARCHAR, hormis le fait que la taille de BINARY et VARBINARY est une taille en octets, et non pas en caractères.
BLOB et TEXT une valeur TEXT est une valeur BLOB insensible à la casse. Pour les index des colonnes BLOB et TEXT, vous devez spécifier une taille d'index. Pour les colonnes de type CHAR et VARCHAR, la taille du préfixe est optionnelle. Il n'y a pas de suppression des espaces finaux lors du stockage de valeur dans des colonnes de type BLOB et TEXT, ce qui est le cas dans pour les colonnes de type VARCHAR. Les colonnes BLOB et TEXT ne peuvent avoir de valeur par défaut. (DEFAULT). Les quatre types BLOB (TINYBLOB, BLOB, MEDIUMBLOB, et LONGBLOB). Les quatre types TEXT (TINYTEXT, TEXT, MEDIUMTEXT, et LONGTEXT)
ENUM Une énumération ENUM est une chaîne dont la valeur est choisie parmi une liste de valeurs autorisées lors de la création de la table. Cette chaîne peut aussi être la chaîne vide ("") ou NULL dans certaines circonstances. Si une colonne d'énumération est déclarée NULL, NULL devient aussi une valeur autorisée, et la valeur par défaut est alors NULL. Si une colonne d'énumération est déclarée NOT NULL, la valeur par défaut est le premier élément de la liste des valeurs autorisées.

        Chaque élément de l'énumération dispose d'un index.
        - Les valeurs de la liste des valeurs autorisées sont indexées à partir de 1.
        - L'index de la valeur NULL est NULL.
        - Une énumération peut avoir un maximum de 65535 éléments.
        - Il est déconseillé de stocker des valeurs numériques dans un ENUM car cela engendre des confusions

SET Un SET est une chaîne qui peut avoir zéro ou plusieurs valeurs, chacune doit être choisie dans une liste de valeurs définies lors de la création de la table. Les valeurs des colonnes SET composées de plusieurs membres sont définies en séparant celles-ci avec des virgules (‘,’). Ce qui fait que la valeur d'un membre de SET ne peut contenir lui même de virgule. Un SET peut avoir au plus 64 membres.

        Par exemple, une colonne définie en tant que SET("un", "deux") NOT NULL peut avoir l'une de ces valeurs:
        ""
        "un"
        "deux"
        "un,deux"

Capacité des colonnes numériques

Type de colonne/Espace requis
TINYINT 1 octet
SMALLINT 2 octets
MEDIUMINT 3 octets
INT, INTEGER 4 octets
BIGINT 8 octets
FLOAT(p) 4 if X ‹= 24 or 8 if 25 ‹= X ‹= 53
FLOAT 4 octets
DOUBLE PRECISION, REAL 8 octets
DECIMAL(M,D) M+2 octets si D › 0, M+1 octets si D=0 (D+2, si M‹D)

Capacité des colonnes temporelles

Type de colonne / Espace requis
DATE 3 octets
DATETIME 8 octets
TIMESTAMP 4 octets
TIME 3 octets
YEAR 1 octet

Capacité des colonnes texte

Type de colonne / Espace requis
CHAR(M) M octets, 1 ‹= M 255
VARCHAR(M) L+1 octets, avec L ‹= M et 1 ‹= M ‹= 255
TINYBLOB, TINYTEXT L+1 octets, avec L ‹ 2^8
BLOB, TEXT L+2 octets, avec L ‹ 2^16
MEDIUMBLOB, MEDIUMTEXT L+3 octets, avec L ‹ 2^24
LONGBLOB, LONGTEXT L+4 octets, avec L ‹ 2^32
ENUM('valeur1','valeur2',...) 1 ou 2 octets, suivant le nombre d'éléments de l'énumération (65535 au maximum)
SET('valeur1','valeur2',...) 1, 2, 3, 4 ou 8 octets, suivant le nombre de membres de l'ensemble (64 au maximum)

Fonctions dans SELECT et WHERE - Priorité des opérateurs

:=
||, OR, XOR
&&, AND
BETWEEN, CASE, WHEN, THEN, ELSE
=, ‹=›, ›=, ›, ‹=, ‹, ‹›, !=, IS, LIKE, REGEXP, IN
|
&
‹‹, ››
-, +
*, /, DIV, %, MOD
^
- (unary minus), (unary bit inversion)
NOT, !
BINARY, COLLATE

Fonctions dans SELECT et WHERE - Opérateurs de comparaison

= Egal

mysql› SELECT 1 = 0 ;
-› 0
mysql› SELECT '0' = 0 ;
-› 1
mysql› SELECT '0.0' = 0 ;
-› 1
mysql› SELECT '0.01' = 0 ;
-› 0
mysql› SELECT '.01' = 0.01 ;
-› 1

‹=› Comparaison compatible avec NULL. Cet opérateur fait une comparaison d'égalité comme l'opérateur =, mais retourne 1 plutôt que NULL si les deux opérandes sont NULL, et 0 plutôt que NULL si un opérande est NULL
‹›, != Différent

mysql› SELECT '.01' ‹› '0.01' ;
-› 1
mysql› SELECT .01 ‹› '0.01' ;
-› 0
mysql› SELECT 'zapp' ‹› 'zappp' ;
-› 1

‹= Inférieur ou égal

mysql› SELECT 0.1 ‹= 2;
-› 1

Strictement inférieur

mysql› SELECT 2 ‹ 2 ;
-› 0

›= Supérieur ou égal

mysql› SELECT 2 ›= 2 ;
-› 1

Strictement supérieur

mysql› SELECT 2 › 2 ;
-› 0

IS NULL, IS NOT NULL Tester si une valeur est ou n'est pas NULL

mysql› SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL ;
-› 0 0 1
mysql› SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL ;
-› 1 1 0

expression BETWEEN min AND max Si expression est supérieure ou égale à min et expression est inférieure ou égale à max, BETWEEN retourne 1, sinon 0. Ceci est équivalent à l'expression (min ‹= expression AND expression ‹= max) si tous les arguments sont du même type. Dans tous les autres cas, la conversion de type prends place, selon les règles suivantes, mais appliquée aux trois arguments.

mysql› SELECT 1 BETWEEN 2 AND 3 ;
-› 0
mysql› SELECT 'b' BETWEEN 'a' AND 'c' ;
-› 1
mysql› SELECT 2 BETWEEN 2 AND '3' ;
-› 1
mysql› SELECT 2 BETWEEN 2 AND 'x-3' ;
-› 0

expr NOT BETWEEN min AND max Même chose que NOT (expr BETWEEN min AND max). COALESCE(list) Retourne le premier élément non-NULL de la liste

mysql› SELECT COALESCE(NULL,1) ;
-› 1
mysql› SELECT COALESCE(NULL,NULL,NULL) ;
-› NULL

GREATEST(value1,value2,...) Avec deux ou plusieurs arguments, retourne la valeur la plus grande. Les arguments sont comparés en utilisant les mêmes règles que pour LEAST()

mysql› SELECT GREATEST(2,0) ;
-› 2
mysql› SELECT GREATEST(34.0,3.0,5.0,767.0) ;
-› 767.0
mysql› SELECT GREATEST('B','A','C') ;
-› 'C'

expr IN (valeur,...) Retourne 1 si expr est l'une des valeurs dans la liste IN, sinon retourne 0. Si toutes les valeurs sont des constantes, toutes les valeurs sont évaluées avec le type de expr et triées. La recherche de l'élément est alors faite en utilisant la recherche binaire. Cela signifie que IN est très rapide si les valeurs contenues dans la liste IN sont toutes des constantes. Si expr est une chaîne sensible à la casse, la comparaison est faite dans un contexte sensible à la casse:

mysql› SELECT 2 IN (0,3,5,'wefwf') ;
-› 0
mysql› SELECT 'wefwf' IN (0,3,5,'wefwf') ;
-› 1

expr NOT IN (value,...) Même chose que NOT (expr IN (valeur,...)).
ISNULL(expr) Si expr est NULL, ISNULL() retourne 1, sinon il retourne 0

mysql› SELECT ISNULL(1+1) ;
-› 0
mysql› SELECT ISNULL(1/0) ;
-› 1

   Notez que la comparaison de deux valeurs NULL en utilisant = donnera toujours false !

INTERVAL(N,N1,N2,N3,...) Retourne 0 si N ‹ N1, 1 si N ‹ N2 etc... Tous les arguments sont traités en tant qu'entiers. Il est requis que N1 ‹ N2 ‹ N3 ‹ ... ‹ Nn pour que cette fonction fonctionne correctement. Cela est due à la recherche binaire utilisée (très rapide)

mysql› SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200) ;
-› 3
mysql› SELECT INTERVAL(10, 1, 10, 100, 1000) ;
-› 2
mysql› SELECT INTERVAL(22, 23, 30, 44, 200) ;
-› 0

LEAST(value1,value2,...) Avec deux arguments ou plus, retourne la plus petite valeur.

mysql› SELECT LEAST(2,0) ;
-› 0
mysql› SELECT LEAST(34.0,3.0,5.0,767.0) ;
-› 3.0
mysql› SELECT LEAST('B','A','C') ;
-› 'A'

Fonctions dans SELECT et WHERE - Opérateurs logiques

NOT, ! (NON) logique. Évalue à 1 si l'opérande est 0, à 0 si l'opérande est non nulle, et NOT NULL retourne NULL. Le dernier exemple donne 1 car l'expression est évaluée comme (!1)+1

mysql› SELECT NOT 10 ;
-› 0
mysql› SELECT NOT 0 ;
-› 1
mysql› SELECT NOT NULL ;
-› NULL
mysql› SELECT ! (1+1) ;
-› 0
mysql› SELECT ! 1+1 ;
-› 1

AND, && (ET) logique. Évalue à 1 si toutes les opérandes sont différentes de zéro et de NULL, à 0 si l'une des opérandes est 0, dans les autres cas, NULL est retourné.

mysql› SELECT 1 && 1 ;
-› 1
mysql› SELECT 1 && 0 ;
-› 0
mysql› SELECT 1 && NULL ;
-› NULL
mysql› SELECT 0 && NULL ;
-› 0
mysql› SELECT NULL && 0 ;
-› 0

   Notez que pour les versions antérieures à la 4.0.5 l'évaluation est interrompue lorsque NULL est rencontré, au lieu de continuer à tester une éventuelle existence de 0. Cela signifie que dans ces versions, SELECT (NULL AND 0) retourne NULL au lieu de 0. En 4.0.5 le code a été revu pour que le résultat réponde toujours au normes ANSI tout en optimisant le plus possible.

OR, || (OU inclusif) logique. Évalue à 1 si aucune opérande n'est nulle, à NULL si l'une des opérandes est NULL, sinon 0 est retourné.

mysql› SELECT 1 || 1 ;
-› 1
mysql› SELECT 1 || 0 ;
-› 1
mysql› SELECT 0 || 0 ;
-› 0
mysql› SELECT 0 || NULL ;
-› NULL
mysql› SELECT 1 || NULL ;
-› 1

XOR (OU exclusif) logique. Retourne NULL si l'une des opérandes est NULL. Pour les opérandes non-NULL, évalue à 1 si un nombre pair d'opérandes est non-nul, sinon 0 est retourné. a XOR b est mathématiquement égal à (a AND (NOT b)) OR ((NOT a) and b).

mysql› SELECT 1 XOR 1 ;
-› 0
mysql› SELECT 1 XOR 0 ;
-› 1
mysql› SELECT 1 XOR NULL ;
-› NULL
mysql› SELECT 1 XOR 1 XOR 1 ;
-› 1

Fonctions dans SELECT et WHERE - Fonctions de contrôle

IFNULL(expr1,expr2) Si l'argument expr1 n'est pas NULL, la fonction IFNULL() retournera l'argument expr1, sinon elle retournera l'argument expr2. La fonction IFNULL() retourne une valeur numérique ou une chaîne de caractères, suivant le contexte d'utilisation

mysql› SELECT IFNULL(1,0) ;
-› 1
mysql› SELECT IFNULL(NULL,10) ;
-› 10
mysql› SELECT IFNULL(1/0,10) ;
-› 10
mysql› SELECT IFNULL(1/0,'oui') ;
-› 'oui'

NULLIF(expr1,expr2) Si l'expression expr1 = expr2 est vrai, la fonction retourne NULL sinon elle retourne expr1. Cela revient à faire CASE WHEN x = y THEN NULL ELSE x END

mysql› SELECT NULLIF(1,1) ;
-› NULL
mysql› SELECT NULLIF(1,2) ;
-› 1

IF(expr1,expr2,expr3) Si l'argument expr1 vaut TRUE (expr1 ‹› 0 et expr1 ‹› NULL) alors la fonction IF() retourne l'argument expr2, sinon, elle retourne l'argument expr3. La fonction IF() retourne une valeur numérique ou une chaîne de caractères, suivant le contexte d'utilisation

mysql› SELECT IF(1ؐ,2,3) ;
-› 3
mysql› SELECT IF(1հ,'oui','non') ;
-› 'oui'
mysql› SELECT IF(STRCMP('test','test1'),'non','oui') ;
-› 'non'

   Si l'argument expr2 ou expr3 est explicitement NULL alors le type du résultat de la fonction IF() est le type de la colonne non NULL. L'argument expr1 est évalué comme un entier, cela signifie que si vous testez un nombre à virgule flottante ou une chaîne de caractères, vous devez utiliser une opération de comparaison

mysql› SELECT IF(0.1,1,0) ;
-› 0
mysql› SELECT IF(0.1‹؎,1,0) ;
-› 1

CASE valeur WHEN [compare-value] THEN résultat [WHEN [compare-value] THEN résultat ...] [ELSE résultat] END,
CASE WHEN [condition] THEN résultat [WHEN [condition] THEN résultat ...] [ELSE résultat] END
La première version retourne résultat si valeur=compare-value. La seconde version retourne le résultat de la première condition qui se réalise. Si aucune des conditions n'est réalisé, alors le résultat de la clause ELSE est retourné. Si il n'y a pas de clause ELSE alors NULL est retourné. Le type de la valeur retournée (INTEGER, DOUBLE ou STRING) est de même type que la première valeur retournée (l'expression après le premier THEN).

mysql› SELECT CASE 1 WHEN 1 THEN "un"
WHEN 2 THEN "deux" ELSE "plus" END ;
-› "un"
mysql› SELECT CASE WHEN 1؎ THEN "vrai" ELSE "faux" END ;
-› "vrai"
mysql› SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END ;
-› NULL

Fonctions dans SELECT et WHERE - Fonctions de chaînes de caractères

   Les fonctions qui traitent les chaînes de caractères retournent NULL si la longueur du résultat finit par dépasser la taille maximale du paramètre max_allowed_packet, défini dans la configuration du serveur.

ASCII(str) Retourne le code ASCII du premier caractère de la chaîne de caractères str. Retourne 0 si la chaîne de caractère str est vide. Retourne NULL si la chaîne de caractères str est NULL. ASCII() fonctionne avec des valeurs numériques entre 0 et 255. Voir aussi la fonction ORD().

mysql› SELECT ASCII('2') ;
-› 50
mysql› SELECT ASCII(2) ;
-› 50
mysql› SELECT ASCII('dx') ;
-› 100

BIN(N) Retourne une chaîne de caractères représentant la valeur binaire de l'argument N, où l'argument N est un nombre de type BIGINT. Cette fonction est un équivalent de CONV(N,10,2). Retourne NULL si l'argument N est NULL.

mysql› SELECT BIN(12) ;
-› '1100'

BIT_LENGTH(str) Retourne le nombre de bits de la chaîne de caractères str.

mysql› SELECT BIT_LENGTH('text') ;
-› 32

CHAR(N,...) La fonction CHAR() interprète les arguments comme des entiers et retourne une chaîne de caractères, constituée des caractères, identifiés par leur code ASCII. Les valeurs NULL sont ignorées

mysql› SELECT CHAR(77,121,83,81,'76') ;
-› 'MySQL'
mysql› SELECT CHAR(77,77.3,'77.3') ;
-› 'MMM'

CHAR_LENGTH(str) Retourne le nombre de caractères de la chaîne str: Un caractère multi-octets compte comme un seul caractère. Cela signifie que pour une chaîne contenant 5 caractères de 2 octets, LENGTH() retournera 10, alors que CHAR_LENGTH() retournera 5.
CHARACTER_LENGTH(str) est un synonyme de CHAR_LENGTH()
COMPRESS(string_to_compress) Compresse une chaîne. Cette fonction requiert la présence de la bibliothèque zlib. Sinon, la valeur retournée sera toujours NULL.

mysql› SELECT LENGTH(COMPRESS(REPEAT('a',1000))) ;
-› 21
mysql› SELECT LENGTH(COMPRESS('')) ;
-› 0
mysql› SELECT LENGTH(COMPRESS('a')) ;
-› 13
mysql› SELECT LENGTH(COMPRESS(REPEAT('a',16))) ;
-› 15

   La chaîne compressée est stockée de cette manière: Les chaînes vides sont stockées comme des chaînes vides; Les chaînes non-vides sont stockées avec 4 octets de plus, indiquant la taille de la chaîne non compressée, suivie de la chaîne compressée. Si la chaîne se termine avec des espaces, un point supplémentaire "." est ajouté, pour éviter que les espaces terminaux soient supprimés de la chaîne. N'utilisez pas les types CHAR ou VARCHAR pour stocker des chaînes compressée. Il est mieux d'utiliser un type BLOB.

CONCAT_WS(separator, str1, str2,...) La fonction CONCAT_WS() signifie CONCAT With Separator, c'est-à-dire "concaténation avec séparateur". Le premier argument est le séparateur utilisé pour le reste des arguments. Le séparateur peut être une chaîne de caractères, tout comme le reste des arguments. Si le séparateur est NULL, le résultat sera NULL. Cette fonction ignorera tous les arguments de valeur NULL et vides, hormis le séparateur. Le séparateur sera ajouté entre tous les arguments à concaténer

mysql› SELECT CONCAT_WS(",","Premier nom","Deuxième nom","Dernier nom");
-› 'Premier nom,Deuxième nom,Dernier nom'
mysql› SELECT CONCAT_WS(",","Premier nom",NULL,"Dernier nom") ;
-› 'Premier nom,Dernier nom'

CONV(N,from_base,to_base) Convertit des nombres entre différentes bases. Retourne une chaîne de caractères représentant le nombre N, convertit de la base from_base vers la base to_base. La fonction retourne NULL si un des arguments est NULL. L'argument N est interprété comme un entier, mais peut être spécifié comme un entier ou une chaîne de caractères. Le minimum pour la base est 2 et son maximum est 36. Si to_base est un nombre négatif, N sera considéré comme un nombre signé. Dans le cas contraire, N sera traité comme un nombre non-signé. La fonction CONV travaille avec une précision de 64 bits

mysql› SELECT CONV("a",16,2) ;
-› '1010'
mysql› SELECT CONV("6E",18,8) ;
-› '172'
mysql› SELECT CONV(-17,10,-18) ;
-› '-H'
mysql› SELECT CONV(10+"10"+'10'+0xa,10,10) ;
-› '40'

ELT(N,str1,str2,str3,...) Retourne str1 si N = 1, str2 si N = 2, et ainsi de suite. Retourne NULL si N est plus petit que 1 ou plus grand que le nombre d'arguments. La fonction ELT() est un complément de la fonction FIELD()

mysql› SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo') ;
-› 'ej'
mysql› SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo') ;
-› 'foo'

EXPORT_SET(bits,on,off,[séparateur,[nombre_de_bits]]) Retourne une chaîne dont tous les bits à 1 dans "bit" sont représentés par la chaîne "on", et dont tous les bits à 0 sont représentés par la chaîne "off". Chaque chaîne est séparée par 'séparateur' (par défaut, une virgule ‘','’) et seul "nombre_de_bits" (par défaut, 64) "bits" est utilisé

mysql› SELECT EXPORT_SET(5,'Y','N',',',4)
-› Y,N,Y,N

FIELD(str,str1,str2,str3,...) Retourne l'index de la chaîne str dans la liste str1, str2, str3, .... Retourne 0 si str n'est pas trouvé. La fonction FIELD() est un complément de la fonction ELT()

mysql› SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') ;
-› 2
mysql› SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo') ;
-› 0

FIND_IN_SET(str,strlist) Retourne une valeur de 1 à N si la chaîne str se trouve dans la liste strlist constituée de N chaînes. Une liste de chaîne est une chaîne composée de sous-chaînes séparées par une virgule ‘,’. Si le premier argument est une chaîne constante et le second, une colonne de type SET, la fonction FIND_IN_SET() est optimisée pour utiliser une recherche binaire très rapide. Retourne 0 si str n'est pas trouvé dans la liste strlist ou si la liste strlist est une chaîne vide. Retourne NULL si l'un des arguments est NULL. Cette fonction ne fonctionne pas correctement si le premier argument contient une virgule ','

mysql› SELECT FIND_IN_SET('b','a,b,c,d') ;
-› 2

HEX(N_or_S) Si l'argument N_OR_S est un nombre, cette fonction retournera une chaîne de caractère représentant la valeur hexadécimale de l'argument N, où l'argument N est de type BIGINT. Cette fonction est un équivalent de CONV(N,10,16). Si N_OR_S est une chaîne de caractères, cette fonction retournera une chaîne de caractères hexadécimale de N_OR_S où chaque caractère de N_OR_S est converti en 2 chiffres hexadécimaux. C'est l'inverse de la chaîne 0xff.

mysql› SELECT HEX(255) ;
-› 'FF'
mysql› SELECT HEX("abc") ;
-› 616263
mysql› SELECT 0x616263 ;
-› "abc"

INSERT(str,pos,len,newstr) Retourne une chaîne de caractères str, après avoir remplacé la portion de chaîne commençant à la position pos et de longueur len caractères, par la chaîne newstr. Cette fonction gère les caractères multi-octets.

mysql› SELECT INSERT('Quadratic', 3, 4, 'What') ;
-› 'QuWhattic'

INSTR(str,substr) Retourne la position de la première occurrence de la chaîne substr dans la chaîne de caractères str. Cette fonction est exactement la même que la fonction LOCATE(), à la différence que ces arguments sont inversés. Cette fonction gère les caractères multi-octets. cette fonction sera sensible à la casse si l'argument est une chaîne de caractères binaire.

mysql› SELECT INSTR('foobarbar', 'bar') ;
-› 4
mysql› SELECT INSTR('xbar', 'foobar') ;
-› 0

LCASE(str) est un synonyme de LOWER().
LEFT(str,len) Retourne les len caractères les plus à gauche de la chaîne de caractères str. Cette fonction gère les caractères multi-octets.

mysql› SELECT LEFT('foobarbar', 5) ;
-› 'fooba'

LENGTH(str) Retourne la taille de la chaîne str, mesurée en octets. Un caractère multi-octets compte comme un seul caractère. Cela signifie que pour une chaîne contenant 5 caractères de 2 octets, LENGTH() retournera 10, alors que CHAR_LENGTH() retournera 5.

mysql› SELECT LENGTH('text') ;
-› 4

LOAD_FILE(file_name) Lit le fichier file_name et retourne son contenu sous la forme d'une chaîne de caractères. Le fichier doit se trouver sur le serveur qui exécute MySQL, vous devez spécifier le chemin absolu du fichier et vous devez avoir les droits en lecture sur celui-ci. Le fichier doit pouvoir être lisible par tous et doit être plus petit que max_allowed_packet. Si ce fichier n'existe pas ou ne peut pas être lu pour différentes raisons, la fonction retourne NULL

mysql› UPDATE tbl_name
SET blob_column=LOAD_FILE("/tmp/picture")
WHERE id=1

LOCATE(substr,str), LOCATE(substr,str,pos) Retourne la position de la première occurrence de la chaîne substr dans la chaîne de caractères str. Retourne 0 si substr ne se trouve pas dans la chaîne de caractères str. Cette fonction gère les caractères multi-octets.

mysql› SELECT LOCATE('bar', 'foobarbar') ;
-› 4
mysql› SELECT LOCATE('xbar', 'foobar') ;
-› 0
mysql› SELECT LOCATE('bar', 'foobarbar',5) ;
-› 7

LOWER(str) Retourne la chaîne str avec tous les caractères en minuscules, en fonction du jeu de caractères courant (par défaut, c'est le jeu ISO-8859-1 Latin1). Cette fonction gère les caractères multi-octets.

mysql› SELECT LOWER('QUADRATIQUE') ;
-› 'quadratique'

LPAD(str,len,padstr) Retourne la chaîne de caractères str, complétée à gauche par la chaîne de caractères padstr jusqu'à ce que la chaîne de caractères str atteigne len caractères de long. Si la chaîne de caractères str est plus longue que len' caractères, elle sera raccourcie de len caractères.

mysql› SELECT LPAD('hi',4,' ??') ;
-› ' ??hi'

LTRIM(str) Retourne la chaîne de caractères str sans les espaces initiaux

mysql› SELECT LTRIM(' barbar') ;
-› 'barbar'

MAKE_SET(bits,str1,str2,...) Retourne une liste (une chaîne contenant des sous-chaînes séparées par une virgule ‘,’) constituée de chaînes qui ont le bit correspondant dans la liste bits. str1 correspond au bit 0, str2 au bit 1, etc... Les chaînes NULL dans les listes str1, str2, ... sont ignorées

mysql› SELECT MAKE_SET(1,'a','b','c') ;
-› 'A'
mysql› SELECT MAKE_SET(1 | 4,'hello','nice','world') ;
-› 'hello,world'
mysql› SELECT MAKE_SET(0,'a','b','c') ;
-› ''

MID(str,pos,len) est un synonyme de SUBSTRING(str,pos,len).
OCT(N) Retourne une chaîne de caractères représentant la valeur octal de l'argument N, où l'argument N est un nombre de type BIGINT. Cette fonction est un équivalent de CONV(N,10,8). Retourne NULL si l'argument N est NULL

mysql› SELECT OCT(12) ;
-› '14'

OCTET_LENGTH(str) est un synonyme de LENGTH().
ORD(str) Si le premier caractère de la chaîne str est un caractère multi-octets, la fonction retourne le code de ce caractère, calculé à partir du code ASCII retourné par cette formule

(1st octet * 256)
+ (2nd octet * 256^2)
+ (3rd octet * 256^3) ...
Si le premier caractère n'est pas un caractère multi-octet, la fonction retournera la même valeur que la fonction ASCII()
mysql› SELECT ORD('2') ;
-› 50

POSITION(substr IN str) est un synonyme de LOCATE(substr,str).
QUOTE(str) Échappe les caractères d'une chaîne pour produire un résultat qui sera exploitable dans une requête SQL. Les caractères suivants seront précédés d'un anti-slash dans la chaîne retournée : le guillemet simple (‘'’), l'anti-slash (‘\’), ASCII NUL, et le Contrôle-Z. Si l'argument vaut NULL, la valeur retournée sera le mot ``NULL'' sans les guillemets simples.

mysql› SELECT QUOTE("Don't") ;
-› 'Don\'t !'
mysql› SELECT QUOTE(NULL) ;
-› NULL

REPEAT(str,count) Retourne une chaîne de caractères constituée de la répétition de count fois la chaîne str. Si count ‹= 0, retourne une chaîne vide. Retourne NULL si str ou count sont NULL

mysql› SELECT REPEAT('MySQL', 3) ;
-› 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str) Retourne une chaîne de caractères str dont toutes les occurrences de la chaîne from_str sont remplacées par la chaîne to_str. Cette fonction gère les caractères multi-octets.

mysql› SELECT REPLACE('www.mysql.com' ;, 'w', 'Ww') ;
-› 'WwWwWw.mysql.com' ;

REVERSE(str) Retourne une chaîne dont l'ordre des caractères est l'inverse de la chaîne str. Cette fonction gère les caractères multi-octets.

mysql› SELECT REVERSE('abc') ;
-› 'cba'

RIGHT(str,len) Retourne les len caractères les plus à droite de la chaîne de caractères str. Cette fonction gère les caractères multi-octets.

mysql› SELECT RIGHT('foobarbar', 4) ;
-› 'rbar'

RPAD(str,len,padstr) Retourne la chaîne de caractères str, complétée à droite par la chaîne de caractères padstr jusqu'à ce que la chaîne de caractères str atteigne len caractères de long. Si la chaîne de caractères str est plus longue que len' caractères, elle sera raccourcie de len caractères.

mysql› SELECT RPAD('hi',5,' ?') ;
-› 'hi ???'

RTRIM(str) Retourne la chaîne de caractères str sans les espaces finaux. Cette fonction gère les caractères multi-octets.

mysql› SELECT RTRIM('barbar ') ;
-› 'barbar'

SOUNDEX(str) Retourne la valeur Soundex de la chaîne de caractères str. Deux chaînes qui ont des sonorités proches auront des valeurs soundex proches. Une chaîne Soundex standard possède 4 caractères, mais la fonction SOUNDEX() retourne une chaîne de longueur arbitraire. Vous pouvez utiliser la fonction SUBSTRING() sur ce résultat pour obtenir une chaîne Soundex standard. Tout caractère non alpha-numérique sera ignoré. Tous les caractères internationaux qui ne font pas partie de l'alphabet de base (A-Z) seront considérés comme des voyelles

mysql› SELECT SOUNDEX('Hello') ;
-› 'H400'
mysql› SELECT SOUNDEX('Quadratically') ;
-› 'Q36324'
expr1 SOUNDS LIKE expr2
Identique à
SOUNDEX(expr1)=SOUNDEX(expr2)

SPACE(N) Retourne une chaîne constituée de N espaces

mysql› SELECT SPACE(6) ;
-› ' '

SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len) Retourne une chaîne de len caractères de long de la chaîne str, à partir de la position pos. La syntaxe ANSI SQL92 utilise une variante de la fonction FROM. Cette fonction gère les caractères multi-octets.

mysql› SELECT SUBSTRING('Quadratically',5) ;
-› 'ratically'
mysql› SELECT SUBSTRING('foobarbar' FROM 4) ;
-› 'barbar'
mysql› SELECT SUBSTRING('Quadratically',5,6) ;
-› 'ratica'

SUBSTRING_INDEX(str,delim,count) Retourne une portion de la chaîne de caractères str, située avant count occurrences du délimiteur delim. Si l'argument count est positif, tout ce qui précède le délimiteur final sera retourné. Si l'argument count est négatif, tout ce qui suit le délimiteur final sera retourné. Cette fonction gère les caractères multi-octets.

mysql› SELECT SUBSTRING_INDEX('www.mysql.com' ;, '.', 2) ;
-› 'www.mysql' ;
mysql› SELECT SUBSTRING_INDEX('www.mysql.com' ;, '.', -2) ;
-› 'mysql.com'

TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str) Retourne la chaîne de caractères str dont tous les préfixes et/ou suffixes remstr ont été supprimés. Si aucun des spécificateurs BOTH, LEADING ou TRAILING sont fournis, BOTH est utilisé comme valeur par défaut. Si remstr n'est pas spécifié, les espaces sont supprimés. Cette fonction gère les caractères multi-octets.

mysql› SELECT TRIM(' bar ') ;
-› 'bar'
mysql› SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx') ;
-› 'barxxx'
mysql› SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx') ;
-› 'bar'
mysql› SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz') ;
-› 'barx'

UCASE(str) UCASE() est un synonyme de UPPER()
UNCOMPRESS(string_to_uncompress) Décompresse une chaîne compressée avec COMPRESS(). Si l'argument n'est pas une valeur compressée, le résultat est NULL. Cette fonction requiert la bibliothèque zlib. Sinon, la valeur retournée est toujours NULL.

mysql› SELECT UNCOMPRESS(COMPRESS('any string')) ;
-› 'any string'
mysql› SELECT UNCOMPRESS('any string') ;
-› NULL

UNCOMPRESSED_LENGTH(compressed_string) Retourne la taille de la chaîne avant compression.

mysql› SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
-› 30

UNHEX(str) Le contraire de HEX(string). C'est à dire, chaque paire de chiffres hexadécimaux sont interprétées comme des nombres, et sont convertis en un caractère représenté par le nombre. Le résultat est retournée sous forme de chaîne binaire.

mysql› SELECT UNHEX('4D7953514C') ;
-› 'MySQL'
mysql› SELECT 0x4D7953514C ;
-› 'MySQL'
mysql› SELECT UNHEX(HEX('string')) ;
-› 'string'
mysql› SELECT HEX(UNHEX('1267')) ;
-› '1267'

UPPER(str) Retourne la chaîne str en majuscules, en fonction du jeu de caractères courant. Par défaut, c'est le jeu ISO-8859-1 Latin1. Cette fonction gère les caractères multi-octets.

mysql› SELECT UPPER('Hey') ;
-› 'HEY'

Fonctions dans SELECT et WHERE - Opérateurs de comparaison de chaînes de caractères

   MySQL convertit automatiquement les nombres en chaînes et et vice-versa. Si vous devez convertir explicitement un nombre en chaîne, passez-le en argument de la fonction CONCAT() ou CAST()

  expr LIKE pat [ESCAPE 'escape-char']

  La réalisation d'expressions utilisant les expressions régulières simples de comparaison de SQL retourne 1 (TRUE) ou 0 (FALSE). Avec LIKE, vous pouvez utiliser les deux jokers suivants:

% Remplace n'importe quel nombre de caractères, y compris aucun
_ Remplace exactement un caractère

mysql› SELECT 'David !' LIKE 'David_' ;
-› 1
mysql› SELECT 'David !' LIKE '%D%v%' ;
-› 1

   Pour tester la présence littérale d'un joker, précédez-le d'un caractère d'échappement. Si vous ne spécifiez pas le caractère d'échappement ESCAPE, le caractère "\" sera utilisé:

\% Remplace le caractère littéral '%'
\_ Remplace le caractère littéral '_'

mysql› SELECT 'David !' LIKE 'David\_' ;
-› 0
mysql› SELECT 'David_' LIKE 'David\_' ;
-› 1
Pour spécifier un caractère d'échappement différent, utilisez la clause ESCAPE:
mysql› SELECT 'David_' LIKE 'David|_' ESCAPE '|' ;
-› 1

   Les deux exemples suivants illustrent le fait que les comparaisons de chaînes de caractères ne sont pas sensibles à la casse à moins qu'une des opérandes soit une chaîne binaire.

mysql› SELECT 'abc' LIKE 'ABC' ;
-› 1
mysql› SELECT 'abc' LIKE BINARY 'ABC' ;
-› 0

   LIKE est également autorisé pour les expressions numériques. (C'est une extension MySQL à la norme ANSI SQL LIKE.)

mysql› SELECT 10 LIKE '1%' ;
-› 1

expr NOT LIKE pat [ESCAPE 'escape-char'] Équivalent à NOT (expr LIKE pat [ESCAPE 'escape-char']).
expr NOT REGEXP pat, expr NOT RLIKE pat Équivalent à NOT (expr REGEXP pat).
expr REGEXP pat, expr RLIKE pat Effectue une recherche de chaîne avec l'expression régulière pat. Le masque peut être une expression régulière étendue. Retourne 1 si expr correspond au masque pat, sinon, retourne 0. RLIKE est un synonyme de REGEXP.

mysql› SELECT 'Monty !' REGEXP 'm%y%%' ;
-› 0
mysql› SELECT 'Monty !' REGEXP '.*' ;
-› 1
mysql› SELECT 'new*\n*line' REGEXP 'new\\*.\\*line' ;
-› 1
mysql› SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A' ;
-› 1 0
mysql› SELECT 'a' REGEXP '^[a-d]' ;
-› 1

STRCMP(expr1,expr2) STRCMP() retourne 0 si les chaînes sont identiques, -1 si la première chaîne est plus petite que la seconde et 1 dans les autres cas:

mysql› SELECT STRCMP('text', 'text2') ;
-› -1
mysql› SELECT STRCMP('text2', 'text') ;
-› 1
mysql› SELECT STRCMP('text', 'text') ;
-› 0

Fonctions dans SELECT et WHERE - Fonctions numériques

Opérations arithmétiques
+ Addition
- Soustraction
- Moins unaire.
Multiplication
/ Division
DIV Division entière

   Fonctions mathématiques

  Toutes les fonctions mathématiques retournent NULL en cas d'erreur.

ABS(X) Retourne la valeur absolue de X. Cette fonction est utilisable avec les valeurs issues des champs BIGINT.

mysql› SELECT ABS(2) ;
-› 2
mysql› SELECT ABS(-32) ;
-› 32

ACOS(X) Retourne l'arc cosinus de X, c'est à dire, la valeur de l'angle dont X est la cosinus. Retourne NULL si X n'est pas dans l'intervalle -1 - 1.

mysql› SELECT ACOS(1) ;
-› 0.000000
mysql› SELECT ACOS(1.0001) ;
-› NULL
mysql› SELECT ACOS(0) ;
-› 1.570796

ASIN(X) Retourne l'arc sinus de X, c'est à dire, la valeur de l'angle dont le sinus est X. Retourne NULL si X n'est pas dans l'intervalle -1 - 1

mysql› SELECT ASIN(0.2) ;
-› 0.201358
mysql› SELECT ASIN('foo') ;
-› 0.000000

ATAN(X) Retourne l'arc tangente de X, c'est à dire, la valeur de l'angle dont la tangente est X.

mysql› SELECT ATAN(2) ;
-› 1.107149
mysql› SELECT ATAN(-2) ;
-› -1.107149

ATAN(Y,X), ATAN2(Y,X) Retourne l'arctangente des variables X et Y. Cela revient à calculer l'arctangente de Y / X, excepté que les signes des deux arguments servent à déterminer le quadrant du résultat

mysql› SELECT ATAN(-2,2) ;
-› -0.785398
mysql› SELECT ATAN2(PI(),0) ;
-› 1.570796

CEILING(X), CEIL(X Retourne la valeur entière supérieure de X. Notez que la valeur retournée sera de type BIGINT

mysql› SELECT CEILING(1.23) ;
-› 2
mysql› SELECT CEILING(-1.23) ;
-› -1

COS(X) Retourne le cosinus de X, où X est donné en radians.

mysql› SELECT COS(PI()) ;
-› -1.000000

COT(X) Retourne la cotangente de X.

mysql› SELECT COT(12) ;
-› -1.57267341
mysql› SELECT COT(0) ;
-› NULL

CRC32(expr) Calcule la somme de contrôle et retourne un entier 32 bits non-signé. Le résultat est la valeur NULL si l'argument est NULL. L'argument attendu est une chaîne, et sera traité comme une chaîne s'il n'est pas du bon type.

mysql› SELECT CRC32('MySQL') ;
-› 3259397556

DEGREES(X) Retourne l'argument X, convertit de radians en degrés.

mysql› SELECT DEGREES(PI()) ;
-› 180.000000

EXP(X) Retourne la valeur de e (la base des logarithmes naturels) élevé à la puissance X.

mysql› SELECT EXP(2) ;
-› 7.389056
mysql› SELECT EXP(-2) ;
-› 0.135335

FLOOR(X) Retourne la valeur entière inférieure de X. Notez que la valeur retournée sera de type BIGINT

mysql› SELECT FLOOR(1.23) ;
-› 1
mysql› SELECT FLOOR(-1.23) ;
-› -2

LN(X) Retourne le logarithme naturel de X (népérien). C'est un synonyme de la fonction LOG(X).

mysql› SELECT LN(2) ;
-› 0.693147
mysql› SELECT LN(-2) ;
-› NULL

LOG(X), LOG(B,X) Appelée avec un seul paramètre, cette fonction retourne le logarithme naturel (népérien) de X. Appelée avec deux paramètres, cette fonction retourne le logarithme naturel de X pour une base B arbitraire

mysql› SELECT LOG(2) ;
-› 0.693147
mysql› SELECT LOG(-2) ;
-› NULL
mysql› SELECT LOG(2,65536) ;
-› 16.000000
mysql› SELECT LOG(1,100) ;
-› NULL

LOG(B,X) est l'équivalent de LOG(X)/LOG(B).
LOG2(X) Retourne le logarithme en base 2 de X. Utile pour trouver combien de bits sont nécessaires pour stocker un nombre

mysql› SELECT LOG2(65536) ;
-› 16.000000
mysql› SELECT LOG2(-100) ;
-› NULL

MOD(N,M), N % M, N MOD M Modulo (équivalent de l'opérateur % dans le langage C). Retourne le reste de la division de N par M. Cette fonction ne pose pas de problèmes avec les BIGINT

mysql› SELECT MOD(234, 10) ;
-› 4
mysql› SELECT 253 % 7 ;
-› 1
mysql› SELECT MOD(29,9) ;
-› 2

PI() Retourne la valeur de pi. Par défaut, 5 décimales sont retournées, mais MySQL utilise la double précision pour pi.

mysql› SELECT PI() ;
-› 3.141593
mysql› SELECT PI()+0.000000000000000000 ;
-› 3.141592653589793116

POW(X,Y), POWER(X,Y) Retourne la valeur de X élevée à la puissance Y

mysql› SELECT POW(2,2) ;
-› 4.000000
mysql› SELECT POW(2,-2) ;
-› 0.250000

RADIANS(X) Retourne l'argument X, converti de degrés en radians.

mysql› SELECT RADIANS(90) ;
-› 1.570796

RAND(), RAND(N) Retourne un nombre aléatoire à virgule flottante compris dans l'intervalle 0 - 1.0. Si l'argument entier N est spécifié, il est utilisé comme initialisation du générateur de nombres aléatoires. Vous ne pouvez pas utiliser une colonne de valeur RAND() dans une clause ORDER BY, parce que ORDER BY va évaluer la colonne plusieurs fois.

mysql› SELECT RAND() ;
-› 0.9233482386203
mysql› SELECT RAND(20) ;
-› 0.15888261251047
mysql› SELECT RAND(20) ;
-› 0.15888261251047
mysql› SELECT RAND() ;
-› 0.63553050033332
mysql› SELECT RAND() ;
-› 0.70100469486881

ROUND(X), ROUND(X,D) Retourne l'argument X, arrondi à un nombre à D décimales. Avec deux arguments, la valeur est arrondie avec D décimales. Si D vaut 0, le résultat n'aura ni de partie décimale, ni de séparateur de décimal. Notez que le comportement de l'opérateur ROUND(), lorsque l'argument est exactement entre deux entiers, dépend de la bibliothèque C active. Certaines arrondissent toujours à l'entier pair le plus proche, toujours vers le haut, toujours vers le bas, ou toujours vers zéro. Si vous avez besoin d'un certain type d'arrondissement, vous devez utiliser une fonction bien définie comme TRUNCATE() ou FLOOR().

mysql› SELECT ROUND(-1.23) ;
-› -1
mysql› SELECT ROUND(-1.58) ;
-› -2
mysql› SELECT ROUND(1.58) ;
-› 2
mysql› SELECT ROUND(1.298, 1) ;
-› 1.3
mysql› SELECT ROUND(1.298, 0) ;
-› 1
mysql› SELECT ROUND(23.298, -1) ;
-› 20

SIGN(X) Retourne le signe de l'argument sous la forme -1, 0, ou 1, selon que X est négatif, zéro, ou positif.

mysql› SELECT SIGN(-32) ;
-› -1
mysql› SELECT SIGN(0) ;
-› 0
mysql› SELECT SIGN(234) ;
-› 1

SIN(X) Retourne le sinus de X, où X est donné en radians.

mysql› SELECT SIN(PI()) ;
-› 0.000000
SQRT(X) Retourne la racine carrée de X.
mysql› SELECT SQRT(4) ;
-› 2.000000
mysql› SELECT SQRT(20) ;
-› 4.472136

TAN(X) Retourne la tangente de X, où X est donné en radians.

mysql› SELECT TAN(PI()+1) ;
-› 1.557408

TRUNCATE(X,D) Retourne l'argument X, tronqué à D décimales. Si D vaut 0, le résultat n'aura ni séparateur décimal, ni partie décimale. Notez que les nombres décimaux ne sont pas stockés exactement comme les nombres entiers , mais comme des valeurs doubles. Vous pouvez être dupés par le résultat suivant (Ce résultat est normal car 10.28 est actuellement stocké comme cela 10.2799999999999999):

mysql› SELECT TRUNCATE(10.28*100,0) ;
-› 1027

Fonctions dans SELECT et WHERE - Dates et heures

ADDDATE(date,INTERVAL expr type), ADDDATE(expr,days) Lorsque utilisé avec la forme INTERVAL, ADDDATE() est un synonyme de DATE_ADD(). La fonction complémentaire SUBDATE() est un synonyme DATE_SUB(). La seconde syntaxe est utilisée si expr est une expression de type DATE ou DATETIME, et que days est un nombre de jour à ajouter à expr.

mysql› SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY) ;
-› '1998-02-02'
mysql› SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY) ;
-› '1998-02-02'
mysql› SELECT ADDDATE('1998-01-02', 31) ;
-› '1998-02-02'

ADDTIME(expr,expr2) ADDTIME() Ajoute expr2 à expr et retourne le résultat. expr est une expression de type DATE ou DATETIME, et expr2 est une expression de type TIME.

mysql› SELECT ADDTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002") ;
-› '1998-01-02 01:01:01.000001'
mysql› SELECT ADDTIME("01:00:00.999999", "02:00:00.999998") ;
-› '03:00:01.999997'

CURDATE(), CURRENT_DATE Retourne la date courante au format 'YYYY-MM-DD' ou YYYYMMDD, suivant le contexte numérique ou chaîne:

mysql› SELECT CURDATE() ;
-› '1997-12-15'
mysql› SELECT CURDATE() + 0 ;
-› 19971215

CURRENT_DATE, CURRENT_DATE() sont synonymes de CURDATE().
CURTIME() Retourne l'heure courante au format 'HH:MM:SS' or HHMMSS suivant le contexte numérique ou chaîne

mysql› SELECT CURTIME() ;
-› '23:50:26'
mysql› SELECT CURTIME() + 0 ;
-› 235026

CURRENT_TIME, CURRENT_TIME() sont synonymes de CURTIME()
CURRENT_TIMESTAMP, CURRENT_TIMESTAMP() sont synonymes de NOW().
DATE(expr) Extrait la partie date de l'expression expr de type DATE ou DATETIME

mysql› SELECT DATE('2003-12-31 01:02:03') ;
-› '2003-12-31'

DATEDIFF(expr,expr2) Retourne le nombre de jours entre la date de début expr et la date de fin expr2. expr et expr2 sont des expressions de type DATE ou DATETIME. Seule la partie DATE est utilisée dans le calcul

mysql› SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30') ;
-› 1
mysql› SELECT DATEDIFF('1997-11-31 23:59:59','1997-12-31') ;
-› -30

DATE_ADD(date,INTERVAL expr type), DATE_SUB(date,INTERVAL expr type) Ces fonctions effectuent des calculs arithmétiques sur les dates. La table suivante indique la signification des arguments type et expr:


type Valeur___________Attendue expr Format

MICROSECOND___________MICROSECONDS
SECOND________________SECONDS
MINUTE________________MINUTES
HOUR__________________HOURS
DAY___________________DAYS
WEEK__________________WEEKS
MONTH ________________MONTHS
QUARTER ______________QUARTERS
YEAR__________________YEARS
SECOND_MICROSECOND____'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND____'MINUTES.MICROSECONDS'
MINUTE_SECOND_________'MINUTES:SECONDS'
HOUR_MICROSECOND______'HOURS.MICROSECONDS'
HOUR_SECOND___________'HOURS:MINUTES:SECONDS'
HOUR_MINUTE___________'HOURS:MINUTES'
DAY_MICROSECOND_______'DAYS.MICROSECONDS'
DAY_SECOND____________'DAYS HOURS:MINUTES:SECONDS'
DAY_MINUTE____________'DAYS HOURS:MINUTES'
DAY_HOUR______________'DAYS HOURS'
YEAR_MONTH ___________'YEARS-MONTHS'

   MySQL autorise tous les signes de ponctuation, comme délimiteur dans le format de expr. Ceux qui sont affichés dans la table sont des suggestions. Si l'argument date est une valeur DATE et que vos calculs impliquent des parties YEAR, MONTH et DAY (c'est à dire, sans partie horaire), le résultat sera de type DATE. Sinon, le résultat est de type DATETIME

mysql› SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND ;
-› '1998-01-01 00:00:00'
mysql› SELECT INTERVAL 1 DAY + '1997-12-31' ;
-› '1998-01-01'
mysql› SELECT '1998-01-01' - INTERVAL 1 SECOND ;
-› '1997-12-31 23:59:59'
mysql› SELECT DATE_ADD('1997-12-31 23:59:59',
-› INTERVAL 1 SECOND) ;
-› '1998-01-01 00:00:00'
mysql› SELECT DATE_ADD('1997-12-31 23:59:59',
-› INTERVAL 1 DAY) ;
-› '1998-01-01 23:59:59'
mysql› SELECT DATE_ADD('1997-12-31 23:59:59',
-› INTERVAL '1:1' MINUTE_SECOND) ;
-› '1998-01-01 00:01:00'
mysql› SELECT DATE_SUB('1998-01-01 00:00:00',
-› INTERVAL '1 1:1:1' DAY_SECOND) ;
-› '1997-12-30 22:58:59'
mysql› SELECT DATE_ADD('1998-01-01 00:00:00',
-› INTERVAL '-1 10' DAY_HOUR) ;
-› '1997-12-30 14:00:00'
mysql› SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY) ;
-› '1997-12-02'
mysql› SELECT DATE_ADD('1992-12-31 23:59:59.000002',
-› INTERVAL '1.999999' SECOND_MICROSECOND) ;
-› '1993-01-01 00:00:01.000001'

   Si vous spécifiez un intervalle qui est trop court (il n'inclut pas toutes les parties d'intervalle attendues par type), MySQL suppose que vous avez omis les valeurs de gauche. Par exemple, si vous spécifiez un type type de DAY_SECOND, la valeur expr devrait contenir des jours, heures, minutes et secondes. Si vous fournissez une valeur de la forme '1:10', MySQL suppose que les jours et heures manquent, et que la valeur représente des minutes et secondes. En d'autres termes, '1:10' DAY_SECOND est interprété comme '1:10' MINUTE_SECOND. C'est similaire au comportement de MySQL avec les valeurs de type TIME, qui représente des durées plutôt que des horaires. Notez que si vous ajoutez ou soustrayez à une valeur de type DATE des horaires, le résultat sera automatiquement au format DATETIME

mysql› SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY) ;
-› '1999-01-02'
mysql› SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR) ;
-› '1999-01-01 01:00:00'

   Si vous utilisez des dates malformées, le résultat sera NULL. Si vous ajoutez des MONTH, YEAR_MONTH ou YEAR, et que le résultat a un jour du mois qui est au-delà de ce qui est possible dans le mois, le jour sera adapté au plus grand jour possible du mois. Par exemple

mysql› SELECT DATE_ADD('1998-01-30', interval 1 month) ;
-› '1998-02-28'

   Notez que dans l'exemple précédent, le mot clé INTERVAL et le spécificateur type sont insensibles à la casse.

DATE_FORMAT(date,format)
Formate la date avec le format. Les spécificateurs suivants peuvent être utilisé dans la chaîne format

%% Un signe pourcentage littéral ‘%’.
%a Nom du jour de la semaine, en abrégé et en anglais (Sun..Sat)
%b Nom du mois, en abrégé et en anglais (Jan..Dec)
%c Mois, au format numérique (1..12)
%d Jour du mois, au format numérique (00..31)
%D Jour du mois, avec un suffixe anglais (1st, 2nd, 3rd, etc.)
%e Jour du mois, au format numérique (0..31)
%f Microsecondes (000000..999999)
%H Heure (00..23)
%h Heure (01..12)
%I Heure (01..12)
%i Minutes, au format numérique (00..59)
%j Jour de l'année (001..366)
%k Heure (0..23)
%l Heure (1..12)
%m Mois, au format numérique (01..12)
%M Nom du mois (January..December)
%p AM ou PM
%r Heures, au format 12 heures (hh:mm:ss [AP]M)
%s Secondes (00..59)
%s Secondes (00..59)
%T Heures, au format 24 heures (hh:mm:ss)
%U Numéro de la semaine (00..53), où Dimanche est le premier jour de la semaine
%u Numéro de la semaine (00..53), où Lundi est le premier jour de la semaine
%V Numéro de la semaine (01..53), où Dimanche est le premier jour de la semaine, utilisé avec '%X'
%v Numéro de la semaine (01..53), où Lundi est le premier jour de la semaine, utilisé avec '%x'
%W Nom du jour de la semaine (Sunday..Saturday)
%w Numéro du jour de la semaine (0=Sunday..6=Saturday)
%X Année, pour les semaines qui commencent le Dimanche, au format numérique, sur 4 chiffres, utilisé avec '%V'
%x Année, pour les semaines qui commencent le Lundi, au format numérique, sur 4 chiffres, utilisé avec '%v'
%y Année, au format numérique, sur 2 chiffres
%Y Année, au format numérique, sur 4 chiffres

Tous les autres caractères sont simplement copiés dans le résultat sans interprétation
mysql› SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y') ;
-› 'Saturday October 1997'
mysql› SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H :%i :%s') ;
-› '22:23:00'
mysql› SELECT DATE_FORMAT('1997-10-04 22:23:00',
'%D %y %a %d %m %b %j') ;
-› '4th 97 Sat 04 10 Oct 277'
mysql› SELECT DATE_FORMAT('1997-10-04 22:23:00',
'%H %k %I %r %T %S %w') ;
-› '22 22 10 10:23:00 PM 22:23:00 00 6'
mysql› SELECT DATE_FORMAT('1999-01-01', '%X %V') ;
-› '1998 52'

DAY(date) DAY() est un synonyme de DAYOFMONTH().
DAYNAME(date) Retourne le nom du jour de la semaine de date

mysql› SELECT DAYNAME('1998-02-05') ;
-› 'Thursday'

DAYOFMONTH(date) Retourne le jour de la date date, dans un intervalle de 1 à 31

mysql› SELECT DAYOFMONTH('1998-02-03') ;
-› 3

DAYOFWEEK(date) Retourne l'index du jour de la semaine: pour date (1 = Dimanche, 2 = Lundi, ... 7 = Samedi). Ces index correspondent au standard ODBC

mysql› SELECT DAYOFWEEK('1998-02-03') ;
-› 3
DAYOFYEAR(date) Retourne le jour de la date date, dans un intervalle de 1 à 366 :
mysql› SELECT DAYOFYEAR('1998-02-03') ;
-› 34

EXTRACT(type FROM date) La fonction EXTRACT() utilise les mêmes types d'intervalles que la fonction DATE_ADD() ou la fonction DATE_SUB(), mais extrait des parties de date plutôt que des opérations de date.

mysql› SELECT EXTRACT(YEAR FROM "1999-07-02") ;
-› 1999
mysql› SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03") ;
-› 199907
mysql› SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03") ;
-› 20102
mysql› SELECT EXTRACT(MICROSECOND FROM "2003-01-02 10:30:00.00123") ;
-› 123

FROM_DAYS(N) Retourne la date correspondant au nombre de jours (N) depuis la date 0. FROM_DAYS() n'est pas fait pour travailler avec des dates qui précèdent l'avènement du calendrier Grégorien (1582), car elle ne prend pas en compte les jours perdus lors du changement de calendrier.

mysql› SELECT FROM_DAYS(729669) ;
-› '1997-10-07'

FROM_UNIXTIME(unix_timestamp) Retourne une représentation de l'argument unix_timestamp sous la forme 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, suivant si la fonction est utilisé dans un contexte numérique ou de chaîne.

mysql› SELECT FROM_UNIXTIME(875996580) ;
-› '1997-10-04 22:23:00'
mysql› SELECT FROM_UNIXTIME(875996580) + 0 ;
-› 19971004222300

   Si format est donné, le résultat est formaté en fonction de la chaîne format. format peut contenir les mêmes options de format que celles utilisées par DATE_FORMAT()

mysql› SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
-› '%Y %D %M %h :%i :%s %x') ;
-› '2003 6th August 06:22:58 2003'

GET_FORMAT(DATE | TIME | TIMESTAMP, 'EUR' | 'USA' | 'JIS' | 'ISO' | 'INTERNAL') Retourne une chaîne de format. Cette fonction est pratique lorsqu'elle est utilisée avec les fonctions DATE_FORMAT() et STR_TO_DATE(). Les trois valeurs possibles pour le premier argument, et les cinq valeurs possible pour le second argument donnent 15 formats d'affichage (pour les options utilisées, voyez la table de la fonction DATE_FORMAT())

Appel fonction / Résultat
GET_FORMAT(DATE,'USA') '%m.%d.%Y'
GET_FORMAT(DATE,'JIS') '%Y-%m-%d'
GET_FORMAT(DATE,'ISO') '%Y-%m-%d'
GET_FORMAT(DATE,'EUR') '%d.%m.%Y'
GET_FORMAT(DATE,'INTERNAL') '%Y%m%d'
GET_FORMAT(TIMESTAMP,'USA') '%Y-%m-%d-%H.%i.%s'
GET_FORMAT(TIMESTAMP,'JIS') '%Y-%m-%d %H :%i :%s'
GET_FORMAT(TIMESTAMP,'ISO') '%Y-%m-%d %H :%i :%s'
GET_FORMAT(TIMESTAMP,'EUR') '%Y-%m-%d-%H.%i.%s'
GET_FORMAT(TIMESTAMP,'INTERNAL') '%Y%m%d%H%i%s'
GET_FORMAT(TIME,'USA') '%h :%i :%s %p'
GET_FORMAT(TIME,'JIS') '%H :%i :%s'
GET_FORMAT(TIME,'ISO') '%H :%i :%s'
GET_FORMAT(TIME,'EUR') '%H.%i.%S'
GET_FORMAT(TIME,'INTERNAL') '%H%i%s'

mysql› SELECT DATE_FORMAT('2003-10-03', GET_FORMAT(DATE, 'EUR')
-› '03.10.2003'
mysql› SELECT STR_TO_DATE('10.31.2003', GET_FORMAT(DATE, 'USA'))
-› 2003-10-31

HOUR(time) Retourne le nombre d'heures pour l'heure time, dans un intervalle de 0 à 23

mysql› SELECT HOUR('10:05:03') ;
-› 10

   Cependant, l'intervalle des valeurs TIME est bien plus grand, et donc, HOUR peut retourner des valeurs plus grandes que 23

mysql› SELECT HOUR('272:59:59') ;
-› 272

LAST_DAY(date) Prend une valeur de format DATE ou DATETIME, et retourne le dernier jour du mois correspondant. Retourne NULL si l'argument est invalide.

mysql› SELECT LAST_DAY('2003-02-05'), LAST_DAY('2004-02-05') ;
-› '2003-02-28', '2004-02-29'
mysql› SELECT LAST_DAY('2004-01-01 01:01:01') ;
-› '2004-01-31'
mysql› SELECT LAST_DAY('2003-03-32') ;
-› NULL

LOCALTIME, LOCALTIME() sont synonymes de NOW().
LOCALTIMESTAMP, LOCALTIMESTAMP() sont synonymes de NOW().
MAKEDATE(year,dayofyear) Retourne une valeur de format DATE, à partir d'une année et du numéro de jour. dayofyear doit être plus grand que 0 ou le résultat sera NULL.

mysql› SELECT MAKEDATE(2001,31), MAKEDATE(2001,32) ;
-› '2001-01-31', '2001-02-01'
mysql› SELECT MAKEDATE(2001,365), MAKEDATE(2004,365) ;
-› '2001-12-31', '2004-12-30'
mysql› SELECT MAKEDATE(2001,0) ;
-› NULL

MAKETIME(hour,minute,second) Retourne une valeur de format TIME, calculée à partir des arguments hour, minute et second.

mysql› SELECT MAKETIME(12,15,30) ;
-› '12:15:30'

MICROSECOND(expr) Retourne le nombre de microsecondes dans l'expression de type TIME ou DATETIME expr, sous la forme d'un nombre entre 0 et 999999.

mysql› SELECT MICROSECOND('12:00:00.123456') ;
-› 123456
mysql› SELECT MICROSECOND('1997-12-31 23:59:59.000010') ;
-› 10

MINUTE(time) Retourne le nombre de minutes pour l'heure time, dans un intervalle de 0 à 59

mysql› SELECT MINUTE('98-02-03 10:05:03') ;
-› 5

MONTH(date) Retourne le numéro du mois de la date date, dans un intervalle de 1 à 12

mysql› SELECT MONTH('1998-02-03') ;
-› 2

MONTHNAME(date) Retourne le nom du mois de la date

mysql› SELECT MONTHNAME("1998-02-05") ;
-› 'February'

NOW() Retourne la date courante au format 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, suivant le contexte numérique ou chaîne

mysql› SELECT NOW() ;
-› '1997-12-15 23:50:26'
mysql› SELECT NOW() + 0 ;
-› 19971215235026

PERIOD_ADD(P,N) Ajoute N mois à la période P (au format YYMM ou YYYYMM). Retourne une valeur dans le format YYYYMM. Notez que l'argument P n'est pas de type date

mysql› SELECT PERIOD_ADD(9801,2) ;
-› 199803

PERIOD_DIFF(P1,P2) Retourne le nombre de mois entre les périodes P1 et P2. P1 et P2 doivent être au format YYMM ou YYYYMM. Notez que les arguments P1 et P2 ne sont pas de type date

mysql› SELECT PERIOD_DIFF(9802,199703) ;
-› 11

QUARTER(date) Retourne le numéro du trimestre de la date date, dans un intervalle de 1 à 4

mysql› SELECT QUARTER('98-04-01') ;
-› 2

SECOND(time) Retourne le nombre de secondes pour l'heure time, dans un intervalle de 0 à 59

mysql› SELECT SECOND('10:05:03') ;
-› 3

SEC_TO_TIME(seconds) Retourne l'argument seconds, convertit en heures, minutes et secondes au format 'HH:MM:SS' ou HHMMSS, suivant le contexte numérique ou chaîne

mysql› SELECT SEC_TO_TIME(2378) ;
-› '00:39:38'
mysql› SELECT SEC_TO_TIME(2378) + 0 ;
-› 3938

STR_TO_DATE(str,format) Cette fonction est l'inverse de la fonction DATE_FORMAT(). Elle prend la chaîne str, et une chaîne de format format, puis retourne une valeur DATETIME. Les valeurs de type DATE, TIME ou DATETIME contenues dans la chaîne str doivent être au format spécifié. Pour les options qui sont utilisables dans la chaîne format, voyez la table dans la description de la fonction DATE_FORMAT(). Tous les autres caractères sont utilisés littéralement, et ne seront pas interprétés. Si str contient une valeur illégale, STR_TO_DATE() retourne NULL.

mysql› SELECT STR_TO_DATE('03.10.2003 09.20', '%d.%m.%Y %H.%i')
-› 2003-10-03 09:20:00
mysql› SELECT STR_TO_DATE('10rap', '%crap')
-› 0000-10-00 00:00:00
mysql› SELECT STR_TO_DATE('2003-15-10 00:00:00', '%Y-%m-%d %H :%i :%s')
-› NULL

SUBDATE(date,INTERVAL expr type), SUBDATE(expr,days) Lorsqu'elle est utilisée avec la forme INTERVAL du second argument, SUBDATE() est synonyme DATE_SUB()

mysql› SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY) ;
-› '1997-12-02'
mysql› SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY) ;
-› '1997-12-02'
mysql› SELECT SUBDATE('1998-01-02 12:00:00', 31) ;
-› '1997-12-02 12:00:00'

SUBTIME(expr,expr2) SUBTIME() Soustrait expr2 de expr et retourne le résultat. expr est une expression de format DATE ou DATETIME et expr2 est une expression de type TIME.

mysql› SELECT SUBTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002") ;
-› '1997-12-30 22:58:58.999997'
mysql› SELECT SUBTIME("01:00:00.999999", "02:00:00.999998") ;
-› '-00:59:59.999999'

SYSDATE() est un synonyme de NOW().
TIME(expr) Extrait la partie horaire de l'expression expr, de type TIME ou DATETIME.

mysql› SELECT TIME('2003-12-31 01:02:03') ;
-› '01:02:03'
mysql› SELECT TIME('2003-12-31 01:02:03.000123') ;
-› '01:02:03.000123'

TIMEDIFF(expr,expr2) TIMEDIFF() retourne la durée entre l'heure de début expr et l'heure de fin expr2. expr et expr2 sont des expressions de type TIME ou DATETIME, et doivent être de même type.

mysql› SELECT TIMEDIFF('2000:01:01 00:00:00', '2000:01:01 00:00:00.000001') ;
-› '-00:00:00.000001'
mysql› SELECT TIMEDIFF('1997-12-31 23:59:59.000001','1997-12-30 01:01:01.000002') ;
-› '46:58:57.999999'

TIMESTAMP(expr), TIMESTAMP(expr,expr2) Avec un seul argument, retourne l'expression expr de type DATE ou DATETIME sous la forme d'une valeur DATETIME. Avec deux arguments, ajouter l'expression expr2 à l'expression expr et retourne le résultat au format DATETIME.

mysql› SELECT TIMESTAMP('2003-12-31') ;
-› '2003-12-31 00:00:00'
mysql› SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00') ;
-› '2004-01-01 00:00:00'

TIMESTAMPADD(interval,int_expr,datetime_expr) Ajoute l'expression entière int_expr à l'expression datetime_expr au format DATE ou DATETIME. L'unité de int_expr est donnée avec l'argument interval, qui peut être l'une des valeurs suivantes : FRAC_SECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, ou YEAR. La valeur interval peut être spécifiée, en utilisant un des mots-clé cités, ou avec le préfixe SQL_TSI_. Par exemple, DAY et SQL_TSI_DAY sont tous les deux valides.

mysql› SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02') ;
-› '2003-01-02 00:01:00'
mysql› SELECT TIMESTAMPADD(WEEK,1,'2003-01-02') ;
-› '2003-01-09'

TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2) Retourne la différence entière entre les expressions datetime_expr1 et datetime_expr2, de format DATE et DATETIME. L'unité du résultat est donné par l'argument interval. Les valeurs légales de interval sont les mêmes que pour la fonction TIMESTAMPADD().

mysql› SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01') ;
-› 3
mysql› SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01') ;
-› -1

TIME_FORMAT(time,format) Cette fonction est utilisée exactement comme la fonction DATE_FORMAT() ci-dessus, mais la chaîne format ne doit utiliser que des spécificateurs d'heures, qui gèrent les heures, minutes et secondes. Les autres spécificateurs génèreront la valeur NULL ou 0. Si la valeur time contient une valeur d'heure qui est plus grande que 23, les formats %H et %k produiront une valeur qui est hors de l'intervalle 0..23. L'autre format d'heure produira une heure modulo 12

mysql› SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l') ;
-› '100 100 04 04 4'

TIME_TO_SEC(time) Retourne l'argument time, convertit en secondes

mysql› SELECT TIME_TO_SEC('22:23:00') ;
-› 80580
mysql› SELECT TIME_TO_SEC('00:39:38') ;
-› 2378

TO_DAYS(date) Retourne le nombre de jours depuis la date 0 jusqu'à la date date. TO_DAYS() n'est pas fait pour travailler avec des dates qui précèdent l'avènement du calendrier Grégorien (1582), car elle ne prend pas en compte les jours perdus lors du changement de calendrier.

mysql› SELECT TO_DAYS(950501) ;
-› 728779
mysql› SELECT TO_DAYS('1997-10-07') ;
-› 729669

UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date) Lorsqu'elle est appelé sans argument, cette fonction retourne un timestamp Unix (nombre de secondes depuis '1970-01-01 00:00:00' GMT). Si UNIX_TIMESTAMP() est appelé avec un argument date, elle retourne le timestamp correspondant à cette date. date peut être une chaîne de type DATE, DATETIME, TIMESTAMP, ou un nombre au format YYMMDD ou YYYYMMDD, en horaire local. Lorsque UNIX_TIMESTAMP est utilisé sur une colonne de type TIMESTAMP, la fonction reçoit directement la valeur, sans conversion explicite. Si vous donnez à UNIX_TIMESTAMP() une date hors de son intervalle de validité, elle retourne 0. Si vous voulez soustraire une colonne de type UNIX_TIMESTAMP(), vous devez sûrement vouloir un résultat de type entier signé.

mysql› SELECT UNIX_TIMESTAMP() ;
-› 882226357
mysql› SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00') ;
-› 875996580

UTC_DATE, UTC_DATE() Retourne la date UTC courante au format 'YYYY-MM-DD' ou YYYYMMDD suivant le contexte numérique ou chaîne

mysql› SELECT UTC_DATE(), UTC_DATE() + 0 ;
-› '2003-08-14', 20030814

UTC_TIME, UTC_TIME() Retourne l'heure UTC courante au format 'HH:MM:SS' or HHMMSS suivant le contexte numérique ou chaîne

mysql› SELECT UTC_TIME(), UTC_TIME() + 0 ;
-› '18:07:53', 180753

UTC_TIMESTAMP, UTC_TIMESTAMP() Retourne l'heure et la date UTC courante au format 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS suivant le contexte numérique ou chaîne

mysql› SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0 ;
-› '2003-08-14 18:08:04', 20030814180804

WEEK(date [,mode]) Avec un seul argument, retourne le numéro de la semaine dans l'année de la date spécifiée, dans un intervalle de 0 à 53 (oui, il peut y avoir un début de semaine numéro 53), en considérant que Dimanche est le premier jour de la semaine. Avec deux arguments, la fonction WEEK() vous permet de spécifier si les semaines commencent le Dimanche ou le Lundi et la valeur retournée sera dans l'intervalle 0-53 ou bien 1-52. Lorsque l'argument mode est omis, la valeur de la variable default_week_format est utilisé. Voici un tableau explicatif sur le fonctionnement du second argument

Valeur / Signification
0 La semaine commence le Sunday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année
1 La semaine commence le Monday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
2 La semaine commence le Sunday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'année
3 La semaine commence le Monday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
4 La semaine commence le Sunday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
5 La semaine commence le Monday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année
6 La semaine commence le Sunday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
7 La semaine commence le Monday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'anné

mysql› SELECT WEEK('1998-02-20') ;
-› 7
mysql› SELECT WEEK('1998-02-20',0) ;
-› 7
mysql› SELECT WEEK('1998-02-20',1) ;
-› 8
mysql› SELECT WEEK('1998-12-31',1) ;
-› 53

   Si vous préférez que le résultat soit calculé en fonction de l'année qui contient le premier jour de la semaine de la date utilisée en argument, vous devriez utiliser les valeurs 2, 3, 6, or 7 de l'argument mode.

mysql› SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0) ;
-› 2000, 0
mysql› SELECT WEEK('2000-01-01',2) ;
-› 52
Alternativement, utilisez la fonction YEARWEEK()
mysql› SELECT YEARWEEK('2000-01-01') ;
-› 199952
mysql› SELECT MID(YEARWEEK('2000-01-01'),5,2) ;
-› '52'

WEEKDAY(date) Retourne l'index du jour de la semaine, avec la conversion suivante : date (0 = Lundi, 1 = Mardi, ... 6 = Dimanche).

mysql› SELECT WEEKDAY('1997-10-04 22:23:00') ;
-› 5
mysql› SELECT WEEKDAY('1997-11-05') ;
-› 2

WEEKOFYEAR(date) Retourne le numéro de semaine dans l'année, sous forme d'un nombre compris entre 1 et 53.

mysql› SELECT WEEKOFYEAR('1998-02-20') ;
-› 8

YEAR(date) Retourne l'année de la date date, dans un intervalle de 1000 à 9999

mysql› SELECT YEAR('98-02-03') ;
-› 1998
mysql› SELECT YEAR('98-02-03') ;
-› 1998

YEARWEEK(date), YEARWEEK(date,start) Retourne l'année et la semaine d'une date. L'argument start fonctionne exactement comme l'argument start de la fonction WEEK(). Notez que l'année dans le résultat peut être différente de l'année passée en argument, pour la première et la dernière semaine de l'année. Notez que le numéro de semaine est différent de celui que la fonction WEEK() retourne (0) pour les arguments optionnels 0 ou 1, comme WEEK() puis retourne la semaine dans le contexte de l'année.

mysql› SELECT YEARWEEK('1987-01-01') ;
-› 198653

Fonctions dans SELECT et WHERE - Fonctions sur les bits

MySQL utilise l'arithmétique des BIGINT (64-bits) pour les opérations sur les bits. Ces opérateurs travaillent donc sur 64 bits.
| OU bit-à-bit (OR). Le résultat est un entier de 64 bits non signé.

mysql› SELECT 29 | 15 ;
-› 31

& ET bit-à-bit (AND). Le résultat est un entier de 64 bits non signé.

mysql› SELECT 29 & 15 ;
-› 13

^ XOR bit-à-bit. Le résultat est un entier de 64 bits non signé.

mysql› SELECT 1 ^ 1 ;
-› 0
mysql› SELECT 1 ^ 0 ;
-› 1
mysql› SELECT 11 ^ 3 ;
-› 8

‹‹ Décale les bits de l'entier (BIGINT) sur la gauche. Le résultat est un entier de 64 bits non signé.

mysql› SELECT 1 ‹‹ 2 ;
-› 4

›› Décale les bits de l'entier (BIGINT) sur la droite. Le résultat est un entier de 64 bits non signé.

mysql› SELECT 4 ›› 2 ;
-› 1

Inverse tous les bits. Le résultat est un entier de 64 bits non signé.

mysql› SELECT 5 & 1 ;
-› 4

BIT_COUNT(N) Retourne le nombre de bits non nuls de l'argument N

mysql› SELECT BIT_COUNT(29) ;
-› 4

Fonctions dans SELECT et WHERE - Fonctions de chiffrement

AES_ENCRYPT(str,key_str), AES_DECRYPT(crypt_str,key_str) Ces fonctions permettent le chiffrement/déchiffrement de données utilisant l'algorithme AES. Une clé de 128 bits est utilisé pour le chiffrement. Les arguments peuvent être de n'importe quelle taille. Si l'un des arguments est NULL, le résultat de cette fonction sera NULL.

Vous pouvez utiliser les fonctions AES pour stocker des données sous une forme chiffrées en modifiant vos requêtes
INSERT INTO t VALUES (1,AES_ENCRYPT("text","password")) ;
Vous pouvez obtenir encore plus de sécurité en évitant de transférer la clé pour chaque requête, en la stockant dans une variable sur le serveur au moment de la connexion
SELECT @password :="my password" ;
INSERT INTO t VALUES (1,AES_ENCRYPT("text",@password)) ;

DECODE(crypt_str,pass_str) Déchiffre la chaîne chiffrée crypt_str en utilisant la clé pass_str. crypt_str doit être une chaîne qui a été renvoyée par la fonction ENCODE().
ENCODE(str,pass_str) Chiffre la chaîne str en utilisant la clé pass_str. Pour déchiffrer le résultat, utilisez la fonction DECODE(). Le résultat est une chaîne binaire de la même longueur que string. Si vous voulez sauvegarder le résultat dans une colonne, utilisez une colonne de type BLOB.
DES_DECRYPT(crypt_str[,key_str]) Déchiffre une chaîne chiffrée à l'aide de la fonction DES_ENCRYPT(). Notez que cette fonction fonctionne uniquement si vous avez configuré MySQL avec le support SSL. Si l'argument key_string n'est pas donné, la fonction DES_DECRYPT() examine le premier bit de la chaîne chiffrée pour déterminer le numéro de clé DES utilisé pour chiffrer la chaîne originale, alors la clé est lu dans le fichier des-key-file pour déchiffrer le message. Pour pouvoir utiliser cela, l'utilisateur doit avoir le privilège SUPER. Si vous passé l'argument key_string à cette fonction, cette chaîne est utilisée comme clé pour déchiffrer le message. Si la chaîne string_to_decrypt ne semble pas être une chaîne chiffrée, MySQL retournera la chaîne string_to_decrypt. Si une erreur survient, cette fonction retourne NULL.
DES_ENCRYPT(str[,(key_num|key_str)]) Chiffre la chaîne avec la clé donnée en utilisant l'algorithme DES. Notez que cette fonction fonctionne uniquement si vous avez configuré MySQL avec le support SSL. La clé de hachage utilisée est choisie en suivant les recommandations suivantes

Un seul argument La première clé de des-key-file est utilisée.
Un numéro de clé Le numéro de la clé donnée (0-9) de des-key-file est utilisée.
Une chaîne La chaîne donnée key_string doit être utilisé pour chiffrer string_to_encrypt.

La chaîne retournée doit être une chaîne binaire où le premier caractère doit être CHAR(128 | key_number).
Le nombre 128 a été ajouté pour reconnaître facilement une clé de hachage. Si vous utilisez une chaîne comme clé, key_number doit être 127.
Si une erreur survient, la fonction retournera NULL.
La longueur de la chaîne de résultat doit être : new_length= org_length + (8-(org_length % 8))+1.
Chaque key_number doit être un nombre dans l'intervalle 0 à 9. Les lignes dans le fichier peuvent être dans n'importe quel ordre. des_key_string est la chaîne qui permettra le chiffrement du message. Entre le nombre et la clé, il doit y avoir au moins un espace. La première clé est la clé par défaut qui sera utilisé si vous ne spécifiez pas d'autres clés en arguments de la fonction DES_ENCRYPT().
Vous pouvez demander à MySQL de lire de nouvelles valeurs de clé dans le fichier de clés avec la commande FLUSH DES_KEY_FILE. Cela requière le privilège Reload_priv.
Un des bénéfices d'avoir une liste de clés par défaut est que cela donne aux applications la possibilité de regarder l'existence de la valeur chiffrée de la colonne, sans pour autant donner la possibilité à l'utilisateur final de déchiffrer ces valeurs.

mysql› SELECT customer_address FROM customer_table WHERE
crypted_credit_card = DES_ENCRYPT("credit_card_number") ;

ENCRYPT(str[,salt]) Chiffre la chaîne str en utilisant la fonction crypt(). L'argument salt doit être une chaîne de deux caractères.

mysql› SELECT ENCRYPT("hello") ;
-› 'VxuFAJXVARROc'

   Si la fonction crypt() n'est pas disponible sur votre système, la fonction ENCRYPT() retournera toujours NULL. La fonction ENCRYPT() conserve uniquement les 8 premiers caractères de la chaîne str, au moins, sur certains système. Le comportement exact est directement déterminé par la fonction système crypt() sous-jacente.

MD5(str) Calcul la somme de vérification MD5 de la chaîne string. La valeur retournée est un entier hexadécimal de 32 caractères qui peut être utilisé, par exemple, comme clé de hachage. C'est l'algorithme RSA ("RSA Data Security, Inc. MD5 Message-Digest Algorithm").

mysql› SELECT MD5("testing") ;
-› 'ae2b1fca515949e5d54fb22b8ed95575'

OLD_PASSWORD(str) retourne la valeur pre-4.1 de PASSWORD()
PASSWORD(str) Calcule un mot de passe chiffré à partir de la chaîne str. C'est cette fonction qui est utilisé pour chiffrer les mots de passes MySQL pour être stockés dans une colonne de type Password de la table user. Le chiffrage par PASSWORD() n'est pas réversible. PASSWORD() n'est pas un chiffrage comparable à la fonction de chiffrage Unix. Voir ENCRYPT(). La fonction PASSWORD() est utilisée durant l'identification au serveur MYSQL. Il est recommandé de ne pas l'utiliser pour vos applications. Utilisez plutôt MD5() ou SHA1().

mysql› SELECT PASSWORD('badpwd') ;
-› '7f84554057dd964b'

SHA1(str), SHA(str) Calcule la somme de vérification SHA1 160 bits de la chaîne string, comme décrit dans la RFC 3174 (Secure Hash Algorithm). La valeur retournée est un entier hexadécimal de 40 caractères, ou bien NULL dans le cas où l'argument vaut NULL. Une des possibilités d'utilisation de cette fonction est le hachage de clé. Vous pouvez aussi l'utiliser comme fonction de cryptographie sûre pour stocker les mots de passe. La fonction SHA1() a été ajoutée dans la version 4.0.2 de MySQL et peut être considérée comme une méthode de cryptographie plus sûre que la fonction MD5(). La fonction SHA() est un alias de la fonction SHA1()

Fonctions dans SELECT et WHERE - Fonctions d'information

BENCHMARK(count,expr) La fonction BENCHMARK() exécute l'expression expr de manière répétée count fois. Elle permet de tester la vélocité de MySQL lors du traitement d'une requête. Le résultat est toujours 0. L'objectif de cette fonction ne se voit que du côté client, qui permet à ce dernier d'afficher la durée d'exécution de la requête. Le temps affiché est le temps côté client, et non pas les ressources processeurs consommées. il est conseillé d'utiliser BENCHMARK() plusieurs fois de suite pour interpréter un résultat, en dehors de charges ponctuelles sur le serveur.

mysql› SELECT BENCHMARK(1000000,ENCODE("bonjour","au revoir")) ;

CHARSET(str) Retourne le jeu de caractères de la chaîne argument.

mysql› SELECT CHARSET('abc') ;
-› 'latin1'
mysql› SELECT CHARSET(CONVERT('abc' USING utf8)) ;
-› 'utf8'
mysql› SELECT CHARSET(USER()) ;
-› 'utf8'

Les valeurs retournées possibles sont (Les valeurs les plus faibles ont la plus haute priorité):
0 Collation explicite
1 Par de collation
2 Collation implicite
3 Coercible

COLLATION(str) Retourne la collation du jeu de caractères de la chaîne argument

mysql› SELECT COLLATION('abc') ;
-› 'latin1_swedish_ci'
mysql› SELECT COLLATION(_utf8'abc') ;
-› 'utf8_general_ci'

CONNECTION_ID() Retourne l'identifiant de connexion courant (thread_id). Chaque connexion a son propre identifiant unique

mysql› SELECT CONNECTION_ID() ;
-› 23786

CURRENT_USER() Retourne le nom d'utilisateur et le nom d'hôte de la session courante. Cette valeur correspond au compte qui a été utilisé durant l'identification auprès du serveur. Cela peut être différent des valeurs de USER().

mysql› SELECT USER() ;
-› 'davida@localhost'
mysql› SELECT * FROM mysql.user ;
ERROR 1044 : Access denied for user : '@localhost' to
database 'mysql'
mysql› SELECT CURRENT_USER() ;
-› '@localhost'

   Cet exemple montre que même si le client a indiqué le nom d'utilisateur davida (comme mentionné par la fonction USER()), le serveur a identifié le client comme un utilisateur anonyme (comme indiqué par la fonction CURRENT_USER()). Une situation qui arrive s'il n'y a aucun compte de listé dans les tables de droits pour davida.

DATABASE() Retourne le nom de la base de données courante. Si aucune base de données n'a été sélectionnée, DATABASE() retourne une chaîne vide. A partir de la version 4.1.1, elle retourne NULL.

mysql› SELECT DATABASE() ;
-› 'test'

FOUND_ROWS() Une commande SELECT peut inclure une clause LIMIT pour restreindre le nombre de lignes qui sera retourné par le client. Dans certains cas, il est mieux de savoir combien de lignes une commande aurait retourné, sans la clause LIMIT, mais sans lancer à nouveau le calcul. Pour cela, ajoutez l'option SQL_CALC_FOUND_ROWS dans la commande SELECT, puis appelez FOUND_ROWS() après.

mysql› SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
-› WHERE id › 100 LIMIT 10 ;
mysql› SELECT FOUND_ROWS() ;

   Le second SELECT retourne un nombre indiquant combien de lignes le premier SELECT aurait retourné s'il n'avait pas été écrit avec une clause LIMIT. Notez que si vous utilisez SELECT SQL_CALC_FOUND_ROWS ..., MySQL calcule toutes les lignes dans la liste des résultats. Ainsi, c'est plus rapide si vous n'utilisez pas de clause LIMIT et que la liste des résultats n'a pas besoin d'être envoyée au client. Si la commande SELECT précédente n'inclut pas l'option SQL_CALC_FOUND_ROWS, alors FOUND_ROWS() pourrait retourner une valeur différente suivant que LIMIT est utilisé ou pas.

   SQL_CALC_FOUND_ROWS et FOUND_ROWS() peuvent être pratiques dans des situations où vous devez limiter le nombre de lignes que la requête retourne, mais que vous devez tout de même connaître le nombre de lignes total, sans exécuter une seconde requête. Un exemple classique est un script web qui présente des résultats de recherche. En utilisant FOUND_ROWS(), vous connaîtrez facilement le nombre de lignes de résultat. L'utilisation de SQL_CALC_FOUND_ROWS et FOUND_ROWS() est plus complexe pour les requêtes UNION que pour les commandes SELECT simples, car LIMIT peut intervenir plusieurs fois dans une commande UNION. Elle sera appliquée à différentes commandes SELECT de la commande UNION, ou globalement à l'UNION.

   Le but de SQL_CALC_FOUND_ROWS pour UNION est de retourner le nombre de lignes qui aurait été retourné sans la clause globale LIMIT. Les conditions d'utilisation de SQL_CALC_FOUND_ROWS avec UNION sont

        - Le mot clé SQL_CALC_FOUND_ROWS doit apparaître dans le premier SELECT de l'UNION.
        - La valeur de FOUND_ROWS() est exactement la même que si UNION ALL était utilisé. Si UNION sans ALL est utilisé, des réductions de doublons surviendront, et la valeur de FOUND_ROWS() sera approximative.
        - Si aucune clause LIMIT n'est présente dans UNION, SQL_CALC_FOUND_ROWS est ignoré et retourne le nombre de lignes dans la table temporaire créé durant le traitement de l'UNION.

LAST_INSERT_ID(), LAST_INSERT_ID(expr) Retourne le dernier identifiant automatiquement généré par une colonne AUTO_INCREMENT.

mysql› SELECT LAST_INSERT_ID() ;
-› 195

   Le dernier ID généré est conservé par le serveur pour chaque connexion. Un autre client ne la modifiera donc pas, même s'ils génèrent une autre valeur AUTO_INCREMENT de leur coté. Ce comportement permet de s'assurer que les actions des autres clients ne perturbe pas les actions du client en cours. La valeur de LAST_INSERT_ID() ne sera pas modifiée non plus si vous modifiez directement la valeur d'une colonne AUTO_INCREMENT avec une valeur simple (c'est à dire, une valeur qui n'est ni NULL, ni 0).

   Si vous insérez plusieurs lignes au même moment avec une requête INSERT, LAST_INSERT_ID() retourne la valeur de la première ligne insérée. La raison à cela est que cela rend possible la reproduction facilement la même requête INSERT sur d'autres serveurs. Si vous utilisez une commande INSERT IGNORE et que la ligne est ignorée, le compteur AUTO_INCREMENT sera malgré tout incrémenté, et LAST_INSERT_ID() retournera une nouvelle valeur. Si expr est donnée en argument à la fonction LAST_INSERT_ID(), alors la valeur de l'argument sera retourné par la fonction et sera enregistré comme étant la prochaine valeur retournée par LAST_INSERT_ID(). Cela peut être utilisé pour simuler des séquences.

Commencez par créer la table suivante
mysql› CREATE TABLE sequence (id INT NOT NULL) ;
mysql› INSERT INTO sequence VALUES (0) ;
Utilisez cette table pour générer des séquences de nombre comme ceci
mysql› UPDATE sequence SET id=LAST_INSERT_ID(id+1) ;
mysql› SELECT LAST_INSERT_ID() ;

   La commande UPDATE incrémente le compteur de séquence, et fait que le prochain appel à LAST_INSERT_ID() va retourner une valeur différente. La commande SELECT lit cette valeur. La fonction C mysql_insert_id() peut aussi être utilisée pour lire la valeur. Vous pouvez générer des séquences sans appeler la fonction LAST_INSERT_ID(), mais l'utilité d'utiliser cette fonction cette fois ci est que la valeur ID est gérée par le serveur comme étant la dernière valeur générée automatiquement. (sécurité multi-utilisateur). Vous pouvez retrouver le nouvelle ID tout comme vous pouvez lire n'importe quelle valeur AUTO_INCREMENT dans MySQL. Par exemple, la fonction LAST_INSERT_ID() (sans argument) devrait retourner la nouvelle ID.

   La fonction C de l'API mysql_insert_id() peut être également utilisée pour trouver cette valeur. Notez que la fonction mysql_insert_id() est incrémentée uniquement après des requêtes INSERT et UPDATE, donc, vous ne pouvez pas utiliser la fonction C de l'API pour trouver la valeur de LAST_INSERT_ID(expr) après avoir exécuté d'autres types de requêtes, comme SELECT ou bien SET.

SESSION_USER() est un synonyme de USER().
SYSTEM_USER() est un synonyme de USER().
USER() Retourne le nom d'utilisateur et le nom d'hôte courant MySQL. La valeur indique le nom d'utilisateur qui a été spécifié lors de l'identification avec le serveur MySQL, et l'hôte client avec lequel il est connecté

mysql› SELECT USER() ;
-› 'davida@localhost'

VERSION() Retourne une chaîne indiquant la version courante du serveur MySQL. Notez que si votre version se termine par -log, cela signifie que le système d'historique est actif.

mysql› SELECT VERSION() ;
-› '4.1.2-alpha-log'

Fonctions dans SELECT et WHERE - Fonctions diverses

FORMAT(X,D) Formate l'argument X en un format comme '#,###,###.##', arrondi à D décimales. Si D vaut 0, le résultat n'aura ni séparateur décimal, ni partie décimale

mysql› SELECT FORMAT(12332.123456, 4) ;
-› '12,332.1235'
mysql› SELECT FORMAT(12332.1,4) ;
-› '12,332.1000'
mysql› SELECT FORMAT(12332.2,0) ;
-› '12,332'

GET_LOCK(str,timeout) Tente de poser un verrou nommé str, avec un délai d'expiration (timeout) exprimé en seconde. Retourne 1 si le verrou a été posé avec succès, 0 si il n'a pas pu être posé avant l'expiration du délai et NULL si une erreur est survenu (comme par exemple un manque de mémoire, ou la mort du thread lui-même, par mysqladmin kill). Un verrou sera levé lorsque vous exécuterez la commande RELEASE_LOCK(), GET_LOCK() ou si le thread se termine. Cette fonction peut être utilisée pour implémenter des verrous applicatifs ou pour simuler des verrous de lignes. Les requêtes concurrentes des autres clients de même nom seront bloquées ; les clients qui s'entendent sur un nom de verrou peuvent les utiliser pour effectuer des verrouillages coopératifs.

mysql› SELECT GET_LOCK("lock1",10) ;
-› 1
mysql› SELECT IS_FREE_LOCK("lock2") ;
-› 1
mysql› SELECT GET_LOCK("lock2",10) ;
-› 1
mysql› SELECT RELEASE_LOCK("lock2") ;
-› 1
mysql› SELECT RELEASE_LOCK("lock1") ;
-› NULL

   Notez que le deuxième appel à RELEASE_LOCK() retourne NULL car le verrou "lock1" a été automatiquement libéré par le deuxième appel à GET_LOCK().

INET_ATON(expr) Retourne un entier qui représente l'expression numérique de l'adresse réseau. Les adresses peuvent être des entiers de 4 ou 8 octets.

mysql› SELECT INET_ATON("209.207.224.40") ;
-› 3520061480

   Le nombre généré est toujours dans l'ordre des octets réseau ; par exemple, le nombre précédent est calculé comme ceci : 209*256^3 + 207*256^2 + 224*256 +40. Depuis MySQL 4.1.2, INET_ATON() comprend aussi les IP courtes

mysql› SELECT INET_ATON('127.0.0.1'), INET_ATON('127.1') ;
-› 2130706433, 2130706433

INET_NTOA(expr) Retourne l'adresse réseau (4 ou 8 octets), de l'expression numérique exp

mysql› SELECT INET_NTOA(3520061480) ;
-› "209.207.224.40"

IS_FREE_LOCK(str) Regarde si le verrou nommé str peut être librement utilisé (i.e., non verrouillé). Retourne 1 si le verrou est libre (personne ne l'utilise), 0 si le verrou est actuellement utilisé et NULL si une erreur survient (comme un argument incorrect).
IS_USED_LOCK(str) Vérifie si le verrou appelé str est actuellement posé ou pas. Si c'est le cas, la fonction retourne l'identifiant de connexion qui a le verrou. Sinon, elle retourne NULL.
MASTER_POS_WAIT(log_name, log_pos) Bloque le maître jusqu'à ce que l'esclave atteigne une position donnée dans le fichier d'historique principal, durant une réplication. Si l'historique principal n'est pas initialisé, retourne NULL. Si l'esclave n'est pas démarré, le maître restera bloqué jusqu'à ce que l'esclave soit démarré et ai atteint la position demandée. Si l'esclave a déjà dépassé cette position, la fonction se termine immédiatement. La valeur retournée est le nombre d'évènements qui a du être traité pour atteindre la position demandée, ou NULL en cas d'erreur. Cette fonction est très utile pour contrôler la synchronisation maître-esclave, mais elle a été initialement écrite pour faciliter les tests de réplications.
RELEASE_LOCK(str) Libère le verrou nommé str, obtenu par la fonction GET_LOCK(). Retourne 1 si le verrou a bien été libéré, 0 si le verrou n'a pas été libéré par le thread (dans ce cas, le verrou reste posé) et NULL si le nom du verrou n'existe pas. Le verrou n'existe pas si il n'a pas été obtenu par la fonction GET_LOCK() ou si il a déjà été libéré. La commande DO est utilisable avec RELEASE_LOCK().
UUID() Retourne un Universal Unique Identifier (UUID) généré grâce à "DCE 1.1 : Remote Procedure Call" (Appendix A) CAE (Common Applications Environment) Specifications, publié par le The Open Group en octobre 1997 (Document numéro C706).

   Un UUID est conçu comme un numéro qui est globalement unique dans l'espace, et le temps. Deux appels à UUID() sont supposés générer deux valeurs différentes, même si ces appels sont faits sur deux ordinateurs séparés, qui ne sont pas connectés ensembles. Un UUID est un nombre de 128 bits, représenté par une chaîne de 5 nombres hexadécimaux, au format aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee: Les trois premiers nombres sont générés à partir d'un timestamp. Le quatrième nombre préserver l'unicité temporelle si le timestamp perd sa monotonie (par exemple, à cause du changement d'heure d'hiver/été). Le cinquième nombre est un nombre IEEE 802 qui fournit l'unicité. Un nombre aléatoire est utilisé la si ce dernier n'est pas disponible (par exemple, comme l'hôte n'a pas de carte Ethernet, nous ne savons pas comment trouver une adresse matériel sur le système d'exploitation). Dans ce cas, l'unicité spatiale ne peut être garantie. Néanmoins, une collision aura une très faible propriété.

mysql› SELECT UUID() ;
-› '6ccd780c-baba-1026-9564-0040f4311e29'

Fonctions dans GROUP BY

AVG(expr) Retourne la moyenne de l'expression expr

mysql› SELECT student_name, AVG(test_score)
-› FROM student
-› GROUP BY student_name ;

BIT_AND(expr) Retourne la combinaison AND bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT).
BIT_OR(expr) Retourne la combinaison OR bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT). Cette fonction retourne 0 s'il n'y a pas de ligne à traiter.
BIT_XOR(expr) Retourne la combinaison XOR bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT). Cette fonction retourne 0 s'il n'y a pas de ligne à traiter.
COUNT(expr) Retourne le nombre de valeurs non-NULL dans les lignes lues par la commande SELECT

mysql› SELECT student.student_name,COUNT(*)
-› FROM student,course
-› WHERE student.student_id=course.student_id
-› GROUP BY student_name ;

COUNT(*) est un peu différente dans son action, car elle retourne le nombre de lignes, même si elles contiennent NULL. COUNT(*) est optimisée pour retourner très rapidement un résultat si SELECT travaille sur une table, qu'aucune autre colonne n'est lue, et qu'il n'y a pas de clause WHERE. Par exemple:

mysql› SELECT COUNT(*) FROM student ;

   Cette optimisation s'applique uniquement pour les tables MyISAM et ISAM, car un compte exact du nombre de lignes est stocké pour ces types de tables, et il peut être lu très rapidement. Pour les moteurs de tables transactionnels, (InnodB, BDB), le stockage de cette valeur est plus problématique, car plusieurs transactions peuvent survenir en même temps, et affecter ce compte.

COUNT(DISTINCT expr,[expr...]) Retourne le nombre de valeurs non-NULL distinctes:

mysql› SELECT COUNT(DISTINCT results) FROM student ;

   Avec MySQL, vous pouvez lire le nombre d'expression distinctes qui ne contiennent pas NULL, en plaçant ici une liste d'expression. Avec SQL-99, vous devriez faire une concaténation de toutes les expressions dans COUNT(DISTINCT ...)

GROUP_CONCAT(expr) Syntaxe complète:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY unsigned_integer | col_name | formula [ASC | DESC] [,col ...]]
[SEPARATOR str_val])
Retourne la chaîne résultant de la concaténation de toutes les valeurs du groupe

mysql› SELECT student_name,
-› GROUP_CONCAT(test_score)
-› FROM student
-› GROUP BY student_name ;
ou:
mysql› SELECT student_name,
-› GROUP_CONCAT(DISTINCT test_score
-› ORDER BY test_score DESC SEPARATOR " ")
-› FROM student
-› GROUP BY student_name ;

   Avec MySQL, vous pouvez obtenir la concaténation d'une série d'expressions. Vous pouvez éliminer les doublons en utilisant DISTINCT. Si vous voulez trier les valeurs du résultat, il faut utiliser ORDER BY. Pour trier en ordre inverse, ajoutez le mot clé DESC (descendant) au nom de la colonne que vous triez dans la clause ORDER BY. Par défaut, l'ordre est ascendant. Cela peut être spécifié explicitement avec le mot clé ASC. SEPARATOR est une chaîne qui sera insérée entre chaque valeur du résultat. La valeur par défaut est une virgule ",". vous pouvez supprimer le séparateur en spécifiant la chaîne vide SEPARATOR "".

   Vous pouvez donner une taille maximale à la variable group_concat_max_len de votre configuration. La syntaxe pour faire cela durant l'exécution est

SET [SESSION | GLOBAL] group_concat_max_len = unsigned_integer ;

   Si une taille maximale a été atteinte, le résultat sera tronqué à cette taille maximale. Note : il y a encore de petites limitations pour GROUP_CONCAT() lorsqu'il faut utiliser des valeurs DISTINCT avec ORDER BY et et en utilisant les valeurs BLOB.

MIN(expr), MAX(expr) Retourne le minimum ou le maximum de expr. MIN() et MAX() peuvent prendre des chaînes comme argument: dans ce cas, elles retournent la valeur minimale ou maximale de la valeur de la chaîne.

mysql› SELECT student_name, MIN(test_score), MAX(test_score)
-› FROM student
-› GROUP BY student_name ;

STD(expr), STDDEV(expr) Retourne la déviation standard de expr la racine carrée de la VARIANCE(). Ceci est une extension au standard SQL 99. La forme STDDEV() de cette fonction est fournie pour assurer la compatibilité Oracle.
SUM(expr) Retourne la somme de expr. Notez que si le résultat ne contient pas de ligne, cette fonction retournera NULL.
VARIANCE(expr) Retourne la variance standard de l'expression expr (en considérant que les lignes forment une population totale, et non pas un échantillon. Le nombre de ligne est le dénominateur.

Procédures stockées et fonctions

   Une procédure stockées est un jeu de commandes SQL qui réside sur le serveur. Une fois qu'elle sont enregistrées, les clients n'ont pas besoin de soumettre chaque commande individuellement, mais peuvent les lancer d'un seul coup.

   Les procédures stockées fournissent un gain de performances, car moins d'informations sont échangées entre le serveur et le client. En échange, cela augmente la charge du serveur, car ce dernier doit réaliser plus de travail. Souvent, il y a de nombreux clients, mais peut de serveurs.

- Les procédures stockées requièrent la table proc dans la base mysql.
- Le droit de CREATE ROUTINE est nécessaire pour créer une procédure stockée.
- Le droit de ALTER ROUTINE est nécessaire pour pouvoir modifier ou effacer une procédure stockée. Le droit est fourni automatiquement au créateur d'une routine.
- Le droit de EXECUTE est requis pour exécuter une procédure stockée. Cependant, ce droit est fourni automatiquement au créateur d'une routine. De plus, la caractéristique par défaut SQL SECURITY est définie (DEFINER), ce qui fait que les utilisateurs qui ont accès à une base de données associée à une routine ont le droit d'exécuter la routine

Déclencheurs

   Un déclencheur est un objet de base de données nommé, qui est associé à une table et qui s'active lorsqu'un événement particulier survient dans une table. les commandes suivantes configurent une table, ainsi qu'un déclencheur pour les commandes INSERT sur cette table. Le déclencheur va effectuer la somme des valeurs insérées dans une des colonnes

mysql› CREATE TABLE account (acct_num INT, amount DECIMAL(10,2)) ;
mysql› CREATE TRIGGER ins_sum BEFORE INSERT ON account
-› FOR EACH ROW SET @sum = @sum + NEW.amount ;

CREATE TRIGGER
CREATE TRIGGER trigger_name trigger_time trigger_event ON tbl_name FOR EACH ROW trigger_stmt

   Le déclencheur est associé à la table appelée tbl_name. tbl_name doit faire référence à une table permanente. Vous ne pouvez pas associer un déclencheur avec une table TEMPORARY ou une vue. trigger_time est le moment d'action du déclencheur. Il peut être BEFORE (avant) ou AFTER (après). trigger_event indique le type de commande qui active le déclencheur. Il peut valoir INSERT, UPDATE ou DELETE. Il ne peut pas y avoir deux déclencheurs pour une même table avec les mêmes configurations de moment et de commande.

   trigger_stmt est la commande à exécuter lorsque le déclencheur s'active. Si vous voulez utiliser plusieurs commandes, utilisez les agrégateurs BEGIN ... END. Cela vous permet aussi d'utiliser les mêmes codes que ceux utilisés dans des procédures stockées. Dans la commande d'activation d'un déclencheur, vous pouvez faire référence aux colonnes dans la table associée au déclencheur en utilisant les mots OLD et NEW. OLD.col_name fait référence à une colonne d'une ligne existante avant sa modification ou son effacement. NEW.col_name fait référence à une colonne d'une ligne après insertion ou modification.

   L'utilisation de SET NEW.col_name = value requiert le droit de UPDATE sur la colonne. L'utilisation de SET value = NEW.col_name requiert le droit de SELECT sur la colonne. La commande CREATE TRIGGER requiert le droit de SUPER.

DROP TRIGGER
DROP TRIGGER tbl_name.trigger_name Supprime un déclencheur. Le nom du déclencheur doit inclure le nom de la table, car chaque déclencheur est associé à une table particulière. La commande DROP TRIGGER requiert le droit de SUPER.

Vues

ALTER VIEW
ALTER VIEW view_name [(column_list)] AS select_statement Cette commande modifie la définition d'une vue. select_statement est le même que pour CREATE VIEW
CREATE VIEW CREATE [OR REPLACE] [ALGORITHM = MERGE | TEMPTABLE] VIEW view_name [(column_list)] AS select_statement [WITH [CASCADED | LOCAL] CHECK OPTION]

Cette commande crée une nouvelle vue, ou remplace une vue existante si la clause OR REPLACE est fournie. La clause select_statement est une commande SELECT qui fournit la définition de la vue. La liste optionnelle de colonnes peut être fournie pour définir explicitement les noms des colonnes. Une vue peut être créée par différents types de commandes SELECT.
Par exemple, SELECT peut faire référence à une table seule, une jointure ou une UNION. La commande SELECT peut ne pas faire de référence à une table. Les exemples suivants définissent une vue qui sélectionne 2 colonnes dans une table, et leur applique une transformation

mysql› CREATE TABLE t (qty INT, price INT) ;
mysql› INSERT INTO t VALUES(3, 50) ;
mysql› CREATE VIEW v AS SELECT qty, price, qty*price AS value FROM t ;
mysql› SELECT * FROM v ;

   Par défaut, la vue est placée dans la base de données par défaut. Pour créer une vue explicitement dans une base de données, spécifiez le nom de la base de données lors de la création: db_name.view_name

mysql› CREATE VIEW test.v AS SELECT * FROM t ;

DROP VIEW
DROP VIEW [IF EXISTS] view_name [, view_name] ... [RESTRICT | CASCADE] DROP VIEW supprime une ou plusieurs vues. Vous devez avoir les droits de DROP pour chaque vue.
SHOW CREATE VIEW
SHOW CREATE VIEW view_name Cette commande montre la commande CREATE VIEW qui créera la vue spécifiée.

INFORMATION_SCHEMA

   Les métadonnées sont des informations sur les données, telles que le nom des bases de données, des tables, le type de données des colonnes ou les droits d'accès. On appelle aussi ces données le dictionnaire de données ou le catalogue système.
^
04 mai 2010

htmlpdflatexmanmd




MySQL - Optimisation

MySQL - Optimisation

Optimisation de MySQL

Limitations et inconvénients conceptuels

   Avec les tables de type MyISAM, MySQL utilise un verrouillage extrêmement rapide (plusieurs lecture / une seule écriture). Le plus gros problème survient quand vous avez un mélange de flux de modifications et des sélections lentes sur la même table. Si c'est un problème sur plusieurs tables, vous pouvez utiliser un autre type de table.

Suite de tests MySQL

crash-me est une page web qui test 450 points, utilisé notamment pour la portabilité. Actuellement vous pouvez vous faire une idée des tests en regardant le code et les résultats dans le répertoire sql-bench.
Les scripts de test ont été écrit en perl et utilisent le module perl DBI. Vous aurez aussi avoir besoin des pilotes spécifiques DBD de chaque serveurs que vous testez.

La suite de tests est située dans le dossier sql-bench. Pour exécuter la suite de tests, lancer run-all-tests
cd sql-bench
perl run-all-tests --server=server_name

Super Smack est un utilitaire de test, qui peut mettre le serveur à genou, utile pour tester les fortes charges du serveur avant sa mise en production.

Optimisation des commandes SELECT et autres requêtes

- Premièrement, ce qui affecte toutes les requêtes: plus votre système de droits est compliqué, plus vous aurez des baisses de performances.
- Si vous n'avez aucun GRANT, MySQL optimisera les vérifications de droit, pour les système volumineux, il est bénéfique d'éviter GRANT.
- Si vous n'avez pas de droits de niveau tables ou colonne, le serveur n'a pas à vérifier le contenu des tables tables_priv et columns_priv.
- Similairement, si vous n'avez pas de limites de ressources, le serveur n'a pas de comptes de ressources à faire.
- si le problème est spécifique à une expression MySQL ou une fonction, vous pouvez utiliser la fonction BENCHMARK() pour effectuer un test de performances. la syntaxe est BENCHMARK(100000,1+1G);

Syntaxe Explain (Obtenir des informations sur SELECT)

EXPLAIN tbl_name ou
EXPLAIN SELECT tbl_name
EXPLAIN tbl_name est un synonyme de DESCRIBE tbl_name ou SHOW COLUMNS FROM tbl_name

   Lorsque vous faite précéder SELECT avec EXPLAIN, MySQL vous explique comment il va traiter la commande SELECT, choisir les tables et index pour les jointures. Avec EXPLAIN, vous pouvez identifier les index à ajouter pour accélérer les commandes SELECT.Vous devriez souvent utiliser la commande ANALYSE TABLE pour mettre à jour les statistiques de cardinalité de vos tables, qui affectent les choix de l'optimiseur.

   En général, lorsque vous voulez rendre un SELECT ... WHERE plus rapide, la première chose à faire est de voir si vous pouvez ajouter des index. Toutes les références entre les tables doivent normalement être faites avec des index. Vous pouvez utiliser la commande EXPLAIN pour déterminer les index utilisés pour le SELECT.

  Pour aider MySQL à mieux optimiser les requêtes, exécutez myisamchk --analyze sur une table après l'avoir remplie avec quelques données consistantes. Cela met à jour une valeur pour chaque partie de l'index qui indique le nombre moyen de lignes qui ont la même valeur. Vous pouvez vérifier le retour de l'exécution d'analyze en faisant SHOW INDEX FROM nom_de_table et examiner la colonne Cardinality.

   Pour trier un index et des données par rapport à un index, utilisez myisamchk --sort-index --sort-records=1 (si vous voulez trier selon le premier index). Notez, toutefois, que ce tri n'est pas le plus optimal et prendra beaucoup de temps pour une grosse table.EXPLAIN affiche la valeur ALL dans la colonne type lorsque MySQL utilise n scans de table pour résoudre une requête. Cela arrive par exemple lorsque la table est si petite qu'il est plus rapide d'analyser la table que d'utiliser les index. C'est un cas courant pour les tables de moins de 10 lignes, et de taille de ligne faible.

Pour éviter les scans de grosses tables
ANAYZE TABLE
Pour forcer l'utilisation d'un index
FORCE INDEX.

Conception

   MySQL conserve les données et les index dans deux fichiers séparés. De nombreux (et en fait presque toutes) les autres bases mélangent les données et les index dans le même fichier.

- Rendre les tables aussi compact que possible
- réduire la taille des données optimise les performances, l'indexation de colonnes de petites taille prend aussi moins de ressources.
- utiliser les types les plus efficaces et les plus petits possible
- utiliser les types d'entiers les plus petits possibles, par exemple MEDIUMINT est préférable a INT
- Déclarez des colonnes NOT NULL si possibles colonnes de taille variable prennent moins de place sur le disque
- la clé primaire doit être aussi courte que possible, cela rend l'identification des lignes plus efficace.
- Ne créer que des index dont vous avez besoin, les index sont bons pour accélérer les lectures, mais sont plus lents pour les écriture des données
- s'il est probable qu'une colonne a un préfixe unique avec les premiers caractères, il est mieux de n'indexer que ce préfixe.
- il peut être parfois intéressant de séparer en 2 une table qui est scannée très souvent.

- tous les types de colonnes de MySQL peuvent être indexés.
- vous pouvez avec tous les gestionnaire de tables avoir au moins 16 clés et une taille d'index d'au moins 256 octets.
- pour les colonnes CHAR et VARCHAR, il est possible d'indexer un préfixe de la colonne.
- les moteurs de table MyISAM et InnoDB supportent aussi l'indexation des colonnes BLOB et TEXT. Lors de l'indexation, vous devez spécifier une taille pour l'index:
CREATE TABLE test (blob_col BLOB, INDEX(blob_col(10)));
- MySQL peut créer des index sur plusieurs colonnes. Un index peut comprendre jusqu'à 15 colonnes (sur les colonnes de type CHAR et VARCHAR, vous pouvez utiliser uniquement le début de la colonne pour l'indexation).
- Un index sur plusieurs colonnes peut être compris comme un tableau trié contenant des valeurs créées par concaténation des valeurs des colonnes indexées.

mysql› CREATE TABLE test (
-› id INT NOT NULL,
-› nom CHAR(30) NOT NULL,
-› prenom CHAR(30) NOT NULL,
-› PRIMARY KEY (id),
-› INDEX nom_index (nom,prenom)) ;
l'index nom_index sera utilisé pour les requêtes suivantes:
mysql› SELECT * FROM test WHERE nom="Widenius" ;
mysql› SELECT * FROM test WHERE nom="Widenius"
-› AND prenom="Michael" ;
mysql› SELECT * FROM test WHERE nom="Widenius"
-› AND (prenom="Michael" OR prenom="Monty") ;
mysql› SELECT * FROM test WHERE nom="Widenius"
-› AND prenom ›="M" AND prenom ‹ "N" ;
mais nom_index ne sera pas utilisé pour:
mysql› SELECT * FROM test WHERE prenom="Michael" ;
mysql› SELECT * FROM test WHERE nom="Widenius"
-› OR prenom="Michael" ;
Tous les index de MySQL (PRIMARY, UNIQUE et INDEX) sont stockés sous la forme de B-tree.

Cache des tables MyISAM

   MyISAM utilise un cache qui garde en mémoire les blocs de tables les plus souvent utilisés. Pour les blocs d'index, un buffer de clés est utilisé. Pour les blocs de données, MySQL n'utilise pas de cache, mais exploite le cache natif du système de fichiers.

  Les accès aux caches de clés sont à accès simultanés entre les threads. Vous pouvez configurer plusieurs caches de clés, et assigner différents index de tables spécifiquement.

  Pour contrôler la taille du cache: key_buffer_size. À 0, le cache est désactivé. Le cache de clé est désactivé si la taille du buffer est top petite.

Sans cache de clé, les fichiers d'index sont lus avec le cache du système de fichier.
Accès au cache: un buffer non modifié est en accès simultanné, s'il est modifié, les threads sont en attente.
Cache de clé multiple: pour assigner un index à un cache spécifique:
CACHE INDEX

Les 2 commandes suivantes assignent les index des tables t1, t2 et t3 au cache de clé appelé hit_cache
mysql› CACHE INDEX t1, t2, t3 IN hot_cache ;


+---------+--------------------+----------+----------+
|--Table--|---------Op---------|-Msg_type-|-Msg_text-|
+---------+--------------------+----------+----------+
|-test.t1-|-assign_to_keycache-|--status--|----OK----|
|-test.t2-|-assign_to_keycache-|--status--|----OK----|
|-test.t3-|-assign_to_keycache-|--status--|----OK----|
+---------+--------------------+----------+----------+

le cache de clé peut être crée en spécifiant sa taille avec le paramètre
mysql› SET GLOBAL keycache1.key_buffer_size=128*1024;
pour détruire le cahce, lui donner une taille de 0
mysql› SET GLOBAL keycache1.key_buffer_size=0;

Pour un serveur en charge, nous recommandons la stratégie suivante pour le cache de clés:
- Un cache de clés principal qui représente 20% de l'espace alloué pour tous les caches de clés. Il sera utilisé par les tables qui sont le plus sollicitées, mais qui ne sont pas modifiées.
- Un cache de clé minoritaire qui représente 20%, Il sera utilisé pour les tables intermédiaires, qui sont intensivement modifiés, comme des tables temporaires par exemple.
- Un cache de clés secondaire qui représente 60% qui sera le cache par défaut, utilisé pour toutes les autres tables.

Stratégie d'insertion au milieu

   Par défaut le système de gestion de cache utilise la stratégie LRU (le moins utilisé est remplacé en premier). On peut choisir la stratégie de l'insertion par le milieu.

  Lors de l'utilisation de la stratégie d'insertion au milieu, la chaîne LRU est divisée en deux parties: une sous-chaîne principale, et une sous-chaîne secondaire. Le point de division entre les deux parties n'est pas fixé, mais le système s'assure que la partie principale n'est pas "trop petite", et qu'elle contient au moins key_cache_division_limit % de bloc de cache de clés. key_cache_division_limit est un composant d'une variable structurée de cache de clé, et sa valeur peut être modifiée indépendamment pour chaque cache.

   Lorsqu'un bloc d'index est lu dans une table, depuis le cache de clé, il est placé à la fin de la sous-chaîne secondaire. Après un certain nombre d'accès, il est promu dans la sous-chaîne principale. Un bloc de la chaîne principale est placé à la fin de la chaîne. Le bloc circule alors dans la la sous-chaîne. Si le bloc reste à la fin de la sous-chaîne suffisamment longtemps, il est rétrogradé dans la chaîne secondaire. Ce temps est déterminé par la valeur du composant key_cache_age_threshold.

  La stratégie de l'insertion au milieu vous permet de garder les blocs les plus utilisés dans le cache. Si vous préférez utiliser la stratégie LRU classique, laissez la valeur de key_cache_division_limit à 100.

   La stratégie d'insertion au milieu aide à améliorer les performances lorsque l'exécution d'une requête qui requiert un scan d'index place dans le cache toutes les valeurs de l'index. Pour éviter cela, vous devez utiliser la stratégie d'insertion au milieu, avec une valeur très inférieure à 100 pour key_cache_division_limit. Les blocs les plus utilisés seront conservés dans le cache durant un tel scan.

Préchargement des index

   S'il y a suffisamment de blocs dans le cache de clé pour contenir tout un index, ou au moins les blocs correspondant aux blocs non-terminaux, alors cela vaut la peine de pré-charger l'index avant de commencer à l'utiliser. Le pré-chargement vous permet de mettre les blocs d'index dans un buffer de cache le plus efficacement : il lit les blocs séquentiellement sur le disque.

Pour pré-charger un index dans un cache
LOAD INDEX INTO CACHE
Par exemple, la commande suivante précharge les index des tables t1 et t2
mysql› LOAD INDEX INTO CACHE t1, t2 IGNORE LEAVES;
L'option
IGNORE LEAVES
fait que les blocs non-terminaux seuls seront lus dans l'index. Par conséquent, la commande ci-dessus va charger tous les blocs de l'index de t1, mais uniquement les blocs non-terminaux de t2
Un cache de clé peut être restructuré à tout moment, en modifiant les valeurs de ses paramètres
mysql› SET GLOBAL cold_cache.key_buffer_size=4*1024*1024;
Si vous assignez une nouvelle valeurs aux variables key_buffer_size ou key_cache_block_size, le serveur va détruire l'ancienne structure du cache, et en recréer un

Quand MySQL ouvre et ferme les tables

table_cache, max_connections et max_tmp_tables affectent le nombre maximum de tables que le serveur garde ouvertes.
table_cache est lié au max_connections.

   Par exemple, pour 200 connexions simultanées, vous devriez avoir un cache de table d'environ 200*n, où n est le nombre maximum de table dans une jointure. Vous devez aussi réserver des pointeurs de fichiers supplémentaires pour les tables temporaires et les fichiers. Assurez vous que votre système d'exploitation peut gérer le nombre de pointeurs de fichiers demandé par l'option table_cache. Si table_cache est trop grand, MySQL peut être à court de pointeurs, et refuser des connexions, échouer à l'exécution de requêtes, ou être très instable. Vous devez aussi prendre en compte que les tables MyISAM peuvent avoir besoin de deux pointeurs de fichiers pour chaque table différente. Vous pouvez augmenter le nombre de pointeurs de fichiers disponibles pour MySQL avec l'option de démarrage -open-files-limit=#.

   Le cache de tables ouvertes reste au niveau de table_cache entrées (par défaut, 64 ; cela peut être modifié avec l'option -O table_cache=# de mysqld). Notez que MySQL peut ouvrir temporairement plus de tables, pour être capable d'exécuter des requêtes.

  Une table qui n'est pas utilisée est refermée, et supprimée du cache de table, dans les circonstances suivantes:

        - Lorsque le cache est plein, et qu'un thread essaie d'ouvrir une table qui n'est pas dans le cache.
        - Lorsque le cache contient plus de table_cache lignes, et qu'aucun thread n'utilise cette table.
        - Lorsque quelqu'un utilise la commande mysqladmin refresh ou mysqladmin flush-tables.
        - Lorsque quelqu'un exécute la commande FLUSH TABLES.

   Si vous ouvrez une table avec HANDLER table_name OPEN, un objet de table dédié sera alloué pour le thread. Cet objet de table n'est pas partagé avec les autres threads, et il ne sera pas fermé avant que le thread n'appelle HANDLER table_name CLOSE, ou que le thread ne meurt

Optimiser le serveur mysql

Si vous avez bcp de RAM et que vous voulez des performances maximales, vous pouvez essayer
shell› safe_mysqld -O key_buffer=64M -O table_cache=256 -O sort_buffer=4M -O read_buffer_size=1M &
Si vous n'avez que 128 Mo et seulement quelques tables, mais que vous demandez beaucoup de classements, vous pouvez essayer cela
shell› safe_mysqld -O key_buffer=16M -O sort_buffer=1M
Si vous avez peu de mémoire et beaucoup de connections, essayez cela
shell› safe_mysqld -O key_buffer=512k -O sort_buffer=100k -O read_buffer_size=100k &
Ou encore
shell› safe_mysqld -O key_buffer=512k -O sort_buffer=16k -O table_cache=32 -O read_buffer_size=8k -O net_buffer_length=1K &

   Si vous utilisez GROUP BY ou ORDER BY sur des fichiers de taille supérieure à la mémoire disponible, vous devriez augmenter la valeur de record_rnd_buffer pour accélérer la lecture des lignes après que le classement ait été fait

  A l'installation de MySQL, un répertoire support-files est créé, et contient plusieurs exemples de fichiers my.cnf: my-huge.cnf, my-large.cnf, my-medium.cnf et my-small.cnf. Vous pouvez les utiliser comme base pour optimiser votre système.

  Si vous avez vraiment beaucoup de connections, des problèmes peuvent apparaître avec le fichier d'échange si mysqld n'a pas été configuré pour utiliser peu de mémoire pour chaque connexion. mysqld fonctionne mieux si vous avez suffisamment de mémoire pour toutes les connections.

Pour voir les effets d'un changement de paramètre, essayez
shell› mysqld -O key_buffer=32m --help

   MySQL 5.0.1 propose une nouvelle méthode plus souple pour l'optimisation, qui permet à l'utilisateur de contrôler l'exhaustivité de la recherche de l'optimisateur dans sa quête pour la méthode la plus efficace pour traiter une requête. L'idée générale est que plus le nombre de méthodes étudiées est petit, moins l'optimisateur prendra de temps à compiler la requête.

  La variable optimizer_prune_level indique à l'optimisateur d'omettre des méthodes basées sur l'estimation du nombre de lignes utilisées dans les tables. Notre expérience montre que ce type de "prévision" échoue rarement, tout en réduisant considérablement le temps de compilation des requêtes. C'est pour cela que cette variable est active par défaut.

   La variable optimizer_search_depth indique la "profondeur" d'analyse de l'optimisateur. Les valeurs les plus faibles de optimizer_search_depth peuvent conduire à de grandes différences dans le temps de compilation. Par exemple, une requête avec 12-13 ou plus peut facilement prendre des heures ou des jours à compiler si optimizer_search_depth a une valeur proche du nombre de tables à traiter. Mais, si optimizer_search_depth vaut 3 ou 4, le compilateur peut traiter cette requête en une minute environ. Si vous n'êtes pas sûrs de la valeur raisonnable de optimizer_search_depth, donnez lui la valeur de 0 pour que l'optimisateur puisse déterminer la valeur automatiquement.

Influence de la compilation et des liaisons sur la vitesse de MySQL

   Les exécutables les plus rapides sont obtenus en liant avec -static. le code le plus rapide sera obtenu en compilant avec pgcc et -O3.

  Il est aussi possible d'utiliser CXX=gcc à la configuration de MySQL pour éviter l'inclusion de la bibliothèque libstdc++ (qui n'est pas nécessaire).

  A la compilation de MySQL, vous devriez uniquement utiliser le support des caractères que vous allez utiliser. (Option --with-charset=xxx.)

Liste des mesures que nous avons effectués

- L'utilisation de pgcc et la compilation complète avec l'option -O6 donne un serveur mysqld 1% plus rapide qu'avec gcc 2.95.2.
- Si vous utilisez la liaison dynamique (sans -static), le résultat est 13% plus lent sur Linux.
- Sachez que vous pouvez néanmoins utiliser la liaison dynamique pour les bibliothèques de MySQL. Seul le serveur a des performances critiques.
- Si vous allégez votre binaire mysqld avec l'option strip libexec/mysqld, vous obtenez un binaire jusqu'à 4% plus rapide.
- Si vous utilisez TCP/IP plutôt que les sockets Unix, le résultat est 7.5% plus lent sur le même ordinateur. (Si vous vous connectez sur localhost, MySQL utilisera les sockets par défaut.)
- Si vous vous connectez en TCP/IP depuis un autre ordinateur avec un lien Ethernet 100 Mo/s, le résultat sera 8 à 11% plus lent.
- L'utilisation de connections sécurisées ( toutes les données chiffrées par le support interne de SSL) pour nos tests comparatifs a provoqué une perte de vitesse de 55%.
- Si vous compilez avec --with-debug=full, vous perdrez 20% de performances sur la plupart des requêtes, mais la perte peut être plus importante sur certaines requêtes
- La compilation sur Linux-x86 avec gcc sans les pointeurs -fomit-frame-pointer ou -fomit-frame-pointer -ffixed-ebp rend mysqld 1 à 4% plus rapide.

Gestion de la mémoire du serveur

- Le buffer de clés (variable key_buffer_size) est partagé par tous les threads. Les autres buffers sont alloués par le serveur suivant les besoins.
- Chaque connexion utilise un espace spécifique au thread:

        - une pile (par défaut, 64 ko, variable thread_stack),
        - un buffer de connexion (variable net_buffer_length),
        - un buffer de résultat (variable net_buffer_length).
        - Le buffer de connexion et celui de résultat sont dynamiquement élargit jusqu'à max_allowed_packet suivant les besoins. Lorsque la requête s'exécute, une copie de la chaîne de requête est aussi allouée.

- Tous les threads partagent la même mémoire de base.
- Chaque requête qui effectue une analyse séquentielle d'une table, alloue un buffer de lecture (variable record_buffer).
- Lors de la lecture de lignes en ordre 'aléatoire' (par exemple, après un tri), un buffer de lecture aléatoire est allouée pour éviter les accès disques (variable record_rnd_buffer).
- Toutes les jointures sont faîtes en une seule passe, et la plupart des jointure sont faîtes sans utiliser de table temporaire. La plupart des table temporaires sont faîtes en mémoire (table HEAP). Les tables temporaires avec beaucoup de données (calculées comme la somme des tailles de toutes les colonnes) ou qui contiennent des colonnes de type BLOB sont sauvées sur le disque.
- La plupart des requêtes qui sont triées allouent un buffer de tri, et entre 0 et 2 fichiers temporaires
- Toute l'analyse et les calculs sont faits en mémoire locale. Aucune mémoire supplémentaire n'est nécessaire pour les petits calculs, et les allocations et libérations de mémoire sont évités. La mémoire n'est allouée que pour les chaînes très grandes
- Chaque fichier d'index est ouvert une fois, et le fichier de données est ouvert pour chaque thread concurrent. Pour chaque thread concurrent, une structure de table, une structure de colonne pour chaque colonne et un buffer de taille 3 * n est alloué (où n est la taille maximale de ligne, en dehors des colonnes de type BLOB). Une colonne de type BLOB utilise 5 à 8 octets de plus que la taille des données du BLOB. Les gestionnaires de table ISAM/MyISAM utilisent un buffer d'une ligne de plus pour leur utilisation interne
- Pour chaque table qui a une colonne BLOB, un buffer est dynamiquement agrandi pour lire les valeurs BLOB. Si vous analysez toute une table, un buffer aussi grand que la plus grande valeur de la colonne BLOB sera alloué.
- Les gestionnaires de tables pour les tables en cours d'utilisation sont sauvées dans un cache, et géré comme une pile FIFO. Normalement, ce cache contient 64 lignes. Si une table doit être utilisée par deux threads concurrents simultanément, le cache contiendra deux entrées pour la table.

MySQL et DNS

- Si votre service DNS est très lent et que vous avez beaucoup d'hôtes, vous pouvez améliorer les performances soit en désactivant le DNS avec --skip-name-resolve, soit en augmentant la taille de HOST_CACHE_SIZE (par défaut : 128) et en recompilant mysqld
- Il est possible de désactiver le cache de noms d'hôte avec --skip-host-cache.
- Il est possible de vider le cache des noms d'hôtes avec FLUSH HOSTS ou avec mysqladmin flush-hosts.
- Si vous ne voulez pas autoriser les connections par TCP/IP, vous pouvez utiliser l'option --skip-networking au démarrage de mysqld.

Problème avec les disques

   Utiliser des liens symboliques

  Cela signifie que vous allez faire un lien symbolique sur le fichier d'index et/ou le fichier de données sur un autre disque. Cela améliore les lectures et écriture.

  Sous Linux, vous pouvez améliorer les performances (jusqu'à 100% en charge n'est pas difficile) en utilisant hdparm pour configurer votre interface disque.

La commande suivante doit être une série de bonnes options de hdparm pour MySQL (et probablement d'autres applications)
hdparm -m 16 -d 1
Si vous n'avez pas besoin de savoir quand un fichier a été accédé la dernière fois (ce qui n'est pas utile avec un serveur de base de données), vous pouvez monter votre système de fichier avec l'option
-o noatime
vous pouvez monter des disques avec l'option
-o async
pour que le système de fichiers soit modifié de manière asynchrone.
^
19 mai 2010

htmlpdflatexmanmd




MySQL - Réplication

MySQL - Réplication

Réplication MySQL

   MySQL supporte la réplication unidirectionnelle interne. Un serveur sert de maître, et les autres servent d'esclaves. Le serveur entretient des logs binaires, ainsi qu'un fichier d'index des logs binaires.

   Chaque esclave, après connexion réussie au serveur maître, indique le point qu'il avait atteint depuis la fin de la dernière réplication, puis récupère les dernière modifications, puis se met en attente des prochains évènements en provenance du maître.

  Un esclave peut aussi servir de maître à son tour, pour réaliser une chaîne de réplication. toute modification des tables sont répliquées, et doivent intervenir sur le serveur maître.

  On peut utiliser la commande LOAD DATA FROM MASTER pour configurer une esclave. Mais ne fonctionne que si toutes les tables du maître sont du type MyISAM, et qu'il est possible d'obtenir un verrou de lecture global, pour qu'aucune lecture ne se fasse durant le transfert des tables depuis le maître.

   Cette limitation est temporaire et sera supprimée une fois le système de sauvegarde programmé. On estime une vitesse de 1Mo par seconde.

  Si le maître est indisponible ou que la connexion est perdue, l'esclave va tenter une reconnexion tous les master-connect-retry secondes.

  Les capacités de réplications de MySQL sont implémentées à l'aide de 3 threads : 1 sur le maitre et 2 sur l'esclave. Lorsque la commande START SLAVE est envoyée, l'esclave crée un thread d'I/O qui se connecte au maître et lit les logs binaires. le maître crée un thread pour envoyer les logs binaires. Ce thread est le Binlog Dump dans le résultat de SHOW PROCESSLIST. Le 3eme thread lit les commandes et les exécute. pour obtenir des info sur les esclaves : SHOW SLAVE STATUS.

Fichiers de relais et de statut de la réplication

   Par défaut ils sont nommés sous la forme host_name-relay-bin.nnnhost_name est le nom de l'esclave. l'esclave garde la trace des logs dans un fichier d'index host_name-relay-bin.index. Les noms par défaut se remplacent avec les options : --relay-log et --relay-log-index.

  ces logs ont le même format que les logs binaires et peuvent être lus avec mysqlbinlog.

  Un log est crée à chaque démarrage du serveur, par la commande FLUSH LOGS ou une taille supérieure à max_relay_log_size.

  Un esclave crée 2 autres fichiers appelés master.info et relay-log.info qui contiennent des informations comme celle affichées par la commande SHOW SLAVE STATUS.

  Si vous perdez les logs, mais que relay-log.info existe, on peut l'étudier pour déterminer ce que le thread SQL a traité, puis utiliser CHANGE MASTER TO avec les options MASTER_RELAY_LOG et MASTER_RELAY_POS pour lui faire relire les logs depuis ce point.

Mise en place de la réplication

   Il est nécessaire d'éteindre brièvement le serveur principal.

  Créer un utilisateur Mysql spécial pour la réplication, avec les droits de REPLICATION SLAVE. Il faut lui donner les droits de réplication depuis tous les esclaves. Le nom d'hôte doit être tel que chaque serveur esclave peut l'utiliser pour se connecter au maître :

  GRANT REPLICATION SLAVE ON generator.php TO replication@'%s' identified by 'password'

  Si on envisage d'utiliser LOAD TABLE FROM MASTER ou LOAD DATA FROM MASTER sur l'esclave, on doit donner des droits supplémentaires : SUPER et RELOAD, ainsi que les droits SELECT sur les tables à charger.

  Si on utilise des tables MyISAM, décharger toutes les tables et blocs en utilisant FLUSH TABLES WITH READ LOCK ; puis faire une sauvegarde des données du maître.

Éventuellement compresser la sauvegarde
tar -cvf /tmp/mysql-snapshot.tar ./cette_base
puis copier l'archive sur l'esclave au même emplacement et la décompresser
tar -xvf /tmp/mysql-snapchot.tar
Il n'est pas besoin de répliquer la base mysql
Lorsque le verrou de lecture a été posé par
FLUSH TABLES WITH READ LOCK
lire les valeurs courantes du fichier de log et de son offset sur le maitre
SHOW MASTER STATUS;
la colonne file montre le nom du fichier de log et la colonne position affiche l'offset. Pour enlever le verrou
UNLOCK TABLES;
pour faire une sauvegarde rapide d'une base InnoDB le mieux est d'arrêter le serveur, puis de copier les fichiers de données InnoDB, leur logs et leur fichier de définition (.frm). Puis utiliser
SHOW MASTER STATUS
Pour noter l'offset courant. Puis éteindre le serveur sans déverrouiller le serveur et vérifier par
mysqladmin -root shutdown
Une alternative, valable pour les 2 types MyISAM et InnoDB est de prendre un export SQL du maître mais c'est plus long
mysqldump -master-data
sur le maitre, puis exécuter les commandes SQL sur les esclaves

- Si le maître fonctionne sans l'option -log-bin, le nom du fichier de log et l'offset seront vides, dans ce cas utiliser la chaîne vide ('') comme nom de fichier de log et la valeur 4 comme offset.
- Dans my.cnf, ajouter les options -log-bin et server-id=unique_number dans le groupe [mysqld]. Chaque serveur doit avoir un identifiant différent.
- Copier la sauvegarde des données dans les esclaves, s'assurer que les droits sur ces données sont corrects. L'utilisateur qui fait fonctionner MySQL doit avoir les droits d'écriture et de lecture sur ces bases, comme le maître.
- Redémarrer les esclaves. lancer l'esclave avec l'option --skip-slave-start s'il était déjà configuré pour la réplication. Utiliser --log-warnings pour plus de détails.
- Si vous avez fait une sauvegarde du maître avec l'utilitaire mysqldump, charger l'export avec mysql -u root -p ‹ dump_file.sql

puis sur l'esclave en utilisant les valeurs lu sur le maître
mysql› CHANGE MASTER TO
-› MASTER_HOST='‹master host name›',
-› MASTER_USER='‹replication user name›',
-› MASTER_PASSWORD='‹replication password›',
-› MASTER_LOG_FILE='‹recorded log file name›',
-› MASTER_LOG_POS=‹recorded log offset› ;
Lancer les thread esclaves
mysql › START SLAVE ;
l'esclave devrait alors se connecter au maître pour rattraper les modifications.

Une fois que l'esclave a initié la réplication, vous trouverez 2 fichiers : master.info et relay.info
Options pour les esclaves, normalement il y'en a pas besoin ils sont dans master.info

--master-host
--master-user
--master-password
--master-port
--master-connect-retry
--master-ssl
--master-ssl-ca
--master-ssl-capath
--master-ssl-cert
--master-ssl-cipher
--master-ssl-key

   Ces commandes sont utilisés lors du lancement de l'esclave la première fois ou après un RESET SLAVE et arrêté puis relancé le serveur. On peut préférer spécifier ces options avec CHANGE MASTER TO.

Exemple de configuration

[mysqld]
server-id=2
master-host=db-master.mycompany.com
master-port=3306
master-user=pertinax
master-password=freitag
master-connect-retry=60
report-host=db-slave.mycompany.com

Options de contrôle de la réplication

--log-slave-updates Dit à l'esclave d'enregistrer les modifications effectuées par son thread SQL dans son propre log binaire. Par défaut, cette option est à Off. Pour que cette option ait un effet, l'esclave doit être lancé avec le log binaire activé. --log-slave-updates sert lorsque vous voulez faire une chaîne de serveur de réplication. Par exemple : A -› B -› C. C'est-à-dire, A sert de maître à l'esclave B, et B sert de maître à l'esclave C. Pour que cela fonctionne, avec B qui sert d'esclave et de maître simultanément, vous devez lancer B avec l'option --log-slave-updates. A et B doivent être lancés avec le log binaire activé.
--log-warnings Fait que l'esclave affiche plus de message sur ses activités Cette option n'est pas limitée à la réplication.
--master-connect-retry=seconds Le nombre de secondes qu'un esclave attend avant de tenter de se re-connecter au maître. Par défaut, elle vaut 60.
--master-host=host Spécifie l'hôte ou l'IP du maître de réplication. Si cette option n'est pas fournie, le thread esclave ne sera pas lancé.
--master-info-file=file_name Le nom à utiliser pour le fichier dans lequel l'esclave stocke les informations sur le maître. Par défaut, c'est mysql.info
--master-password=password Le mot de passe que l'esclave utilise lors de l'identification auprès du maître
--master-port=port_number Le port du maître que l'esclave utilise lors de l'identification auprès du maître. Si le port n'est pas configuré, la valeur de la variable MYSQL_PORT est utilisée. Si vous n'y avez pas touché lors de la compilation avec configure, ce doit être 3306
--master-ssl
--master-ssl-ca=file_name
--master-ssl-capath=directory_name
--master-ssl-cert=file_name
--master-ssl-cipher=cipher_list
--master-ssl-key=file_name Ces options servent à configurer la réplication chiffrée, lorsque la connexion avec le maître utilise SSL. Leurs significations respectives est la même que les options --ssl, --ssl-ca, --ssl-capath, --ssl-cert, --ssl-cipher, --ssl-key
--master-user=username Le nom d'utilisateur que l'esclave utilise lors de l'identification auprès du maître. Le compte doit avoir les droits de REPLICATION SLAVE. Si l'utilisateur maître n'est pas configuré, l'utilisateur test est utilisé.
--max-relay-log-size=# Pour faire la rotation automatique des logs.
--read-only Cette option fait que le serveur n'autorise aucune modification, hormis celles du thread esclave, ou celle des utilisateurs ayant les droits de SUPER. Cela peut être utile si vous voulez vous assurer que l'esclave ne reçoit aucune modification des clients.
--relay-log=filename Pour spécifier la localisation et le nom qui doivent être utilisés pour les logs de relais. Les noms par défaut sont de la forme host_name-relay-bin.nnn, où host_name est le nom du serveur esclave et nnn indique le numéro de séquence du log de relais. Vous pouvez utiliser ces options pour avoir des noms de fichier de log de relais indépendants du nom d'hôte, ou si vos logs ont tendances à devenir très grands (et que vous ne voulez pas réduire la valeur de max_relay_log_size) et que vous devez les mettre dans un autre dossier, ou simplement pour accélérer la vitesse d'équilibrage entre deux disques.
--relay-log-index=filename Pour spécifier la localisation et le nom qui doivent être utilisés pour le fichier d'index du log de relais. Le nom par défaut est host_name-relay-bin.index, où host_name est le nom du serveur esclave.
--relay-log-info-file=filename Pour donner au fichier relay-log.info un autre nom ou pour le placer dans un autre dossier. Le nom par défaut est relay-log.info dans le dossier de données.
--relay-log-purge=0|1 Active ou désactive la vidange automatique des logs de relais, dès qu'ils ne sont plus utiles. C'est une variable globale, qui peut être dynamiquement modifiée avec SET GLOBAL RELAY_LOG_PURGE=0|1. Sa valeur par défaut est 1.
--relay-log-space-limit=# Limite la taille maximale de tous les fichiers de logs de relais sur l'esclave (une valeur de 0 signifie "sans limite"). Lorsque la limite est atteinte, le thread d'I/O fait une pause : il ne lit plus rien dans le log binaire du maître, jusqu'à ce que le thread SQL ait avancé, et effacé des fichiers de logs. Notez que cette limite n'est pas absolue. Avec --relay-log-space-limit, il ne faut pas utiliser de valeur inférieure à deux fois la taille de --max-relay-log-size (ou --max-binlog-size si --max-relay-log-size vaut 0) car dans ce cas, il y a des chances que le thread d'I/O attende de l'espace libre parce que --relay-log-space-limit est dépassée, mais que le thread SQL n'ait pas de logs à effacer, et ne peut donc libérer le thread d'I/O, forcant le thread d'I/O à ignorer temporairement --relay-log-space-limit.
--replicate-do-db=db_name Indique à l'esclave qu'il doit restreindre la réplication aux commandes qui utilisent la base de données db_name par défaut (c'est à dire celle qui est sélectionnée avec la commande USE). Pour spécifier plusieurs base de données, utilisez cette option aussi souvent que nécessaire. Noter que cela ne va pas autoriser les commandes multi-bases, comme UPDATE some_db.some_table SET foo='bar' si une base de données différente ou qu'aucune base de données n'est sélectionnée. Si vous avez besoin que les commandes multi-bases fonctionnent, utilisez --replicate-wild-do-table=db_name.%

Un exemple qui pourrait ne pas fonctionner comme vous l'attendez: si l'esclave est lancé avec --replicate-do-db=sales et que vous émettez une commande sur le maître, la commande UPDATE suivante ne sera pas répliquée:
USE prices;
UPDATE sales.january SET amount=amount+1000 ;
Si vous avez besoin de répliquer des commandes multi-bases, utilisez l'option --replicate-wild-do-table=db_name.% à la place.
La raison principale de ce comportement "vérifie juste la base par défaut" est qu'il est difficile de savoir si une requête doit être répliquée, uniquement à partir de la requête. Par exemple, si vous utilisez une requête multi-tables DELETE ou multi-tables UPDATE, qui a des conséquences dans d'autres bases. La vérification de la base courante est aussi très rapide.

--replicate-do-table=db_name.table_name Dit à l'esclave qu'il doit restreindre la réplication à une table spécifiée. Pour spécifier plusieurs tables, il faut utiliser cette directive plusieurs fois, une fois par table. Cela fonctionnera pour les mises à jours multi-bases, au contraire de --replicate-do-db
--replicate-ignore-db=db_name Indique à l'esclave qu'il doit ne doit pas assurer la réplication avec les commandes qui utilisent la base de données db_name par défaut (c'est à dire celle qui est sélectionnée avec la commande USE). Pour spécifier plusieurs base de données, utilisez cette option aussi souvent que nécessaire. Note que cela ne va pas autoriser les commandes multi-bases, comme UPDATE some_db.some_table SET foo='bar' si une base de données différente ou qu'aucune base de données n'est sélectionnée. Si vous avez besoin que les commandes multi-bases fonctionnent, assurez vous que vous avez MySQL 3.23.28 ou plus récent, et utilisez --replicate-wild-do-table=db_name.%

Un exemple qui pourrait ne pas fonctionner comme vous l'attendez: si l'esclave est lancé avec --replicate-ignore-db=sales et que vous émettez une commande sur le maître, la commande UPDATE suivante ne sera pas répliquée
USE prices;
UPDATE sales.january SET amount=amount+1000;
Si vous avez besoin de répliquer des commandes multi-bases, utilisez l'option --replicate-wild-ignore-table=db_name.% à la place

--replicate-ignore-table=db_name.table_name Dit à l'esclave qu'il ne doit pas répliquer les commandes qui touchent à la table spécifiée, même si d'autres tables sont modifiées dans la même commande. Pour spécifier plusieurs tables, il faut utiliser cette directive plusieurs fois, une fois par table. Cela fonctionnera pour les mises à jours multi-bases, au contraire de --replicate-ignore-db

Notes sur cette liste d'options

--replicate-wild-do-table=db_name.table_name Dit à l'esclave qu'il doit restreindre la réplication aux tables dont le nom vérifie le masque spécifié. Le masque peut contenir les caractères ‘%’ et ‘_’, qui ont la même signification que dans les expressions régulières de la clause LIKE. Pour spécifier plusieurs tables, il faut utiliser cette directive plusieurs fois, une fois par table. Cela fonctionnera pour les mises à jours multi-bases, au contraire de --replicate-do-db

Exemple :
--replicate-wild-do-table=foo%.bar%
va répliquer les mises à jour qui surviennent sur toutes les tables de toutes les bases qui commencent par foo, et dont le nom de table commence par bar.

   Notez que si vous utilisez --replicate-wild-do-table=foo%.%, alors la règle sera propagée à CREATE DATABASE et DROP DATABASE, c'est à dire que ces deux commandes seront répliquées si le nom de la base correspond au masque (foo% ici) (la magie est ici déclenchée par % comme masque de table.).

  Si le masque de noms de tables est %, il accepte tous les noms de tables et les options s'appliquent aux commandes de niveau base de données (comme CREATE DATABASE, DROP DATABASE et ALTER DATABASE). Par exemple, si vous utilisez --replicate-wild-do-table=foo%.%, les commandes de niveau de base de données seront répliquées si le nom de la base de données est accepté par le masque foo%.

   Si vous voulez faire la réplication des tables du type ma_petite%base (ceci est le nom exact de la base), mais que vous ne voulez pas répliquer la base ma1petiteAABCbase, vous devez protéger les caractères '_' et '%': il faut utiliser une syntaxe équivalent à: replicate-wild-do-table=my\_own\%db. Et si vous spécifiez cette option en ligne de commande, suivant votre système, vous devrez protéger aussi le caractère \ (par exemple, en Shell bash, vous devez émettre une option sous la forme --replicate-wild-do-table=my\\_own\\%db).

--replicate-wild-ignore-table=db_name.table_name Dit à l'esclave qu'il ne doit pas répliquer les tables dont le nom vérifie le masque spécifié. Pour spécifier plusieurs tables, il faut utiliser cette directive plusieurs fois, une fois par table. Cela fonctionnera pour les mises à jours multi-bases, au contraire de --replicate-do-db.

Exemple
--replicate-wild-ignore-table=foo%.bar%
n'autorisera pas de modifications dans les tables des bases dont le nom commence par foo et dont le nom de table commence par bar. Pour des informations sur le fonctionnement du filtre, voyez l'option --replicate-wild-ignore-table. La règle pour inclure des caractères littéraux est la même que pour --replicate-wild-ignore-table.

--replicate-rewrite-db=from_name-›to_name Dit à l'esclave de remplacer la base courante (celle qui est sélectionnée avec USE) par to_name si elle était from_name sur le maître. Seules les commandes impliquant des tables peuvent être affectées. (CREATE DATABASE, DROP DATABASE ne le seront pas), et uniquement si from_name était la base de données courante sur le maître. Cela ne fonctionnera pas pour les commandes multi-bases de données. Notez que la traduction est faite avant que les règles --replicate-* ne soient testées.

Si vous utilisez cette option en ligne de commande, et que vous utilisez le caractère ‘’, qui peut être spécial pour votre interpréteur Shell, protégez-le comme ceci :
shell› mysqld --replicate-rewrite-db="olddb-›newdb"

--replicate-same-server-id À utiliser sur les serveurs esclaves. Généralement, vous pouvez spécifier la valeur 0 pour éviter les réplications infinies. Si cette option vaut 1, l'esclave n'ignorera pas les événements de réplication, même s'ils portent son propre numéro d'identification. Normalement, cela n'est utile que pour de très rares configurations. Vous ne pouvez pas mettre cette option à 1 si --log-slave-updates est utilisé.
--report-host=host Le nom d'hôte ou l'adresse IP de l'esclave, qui doit être indiquée lors de l'enregistrement de l'esclave chez le maître. Cela apparaîtra dans l'affichage de la commande SHOW SLAVE HOSTS. Laissez cette option vide pour que l'esclave ne s'enregistre pas sur le maître. Notez qu'il n'est pas suffisant pour que le maître lise l'adresse IP de l'esclave sur le socket, une fois que l'esclave se connecte. À cause du NAT et des problèmes de routages, cette IP peut être invalide pour se connecter au maître depuis l'hôte ou les autres esclaves.
--report-port=port_number Le port de connexion indiqué par l'esclave lors de son enregistrement chez le maître. Configurez cette option si l'esclave utilise un port autre que le port par défaut, ou si vous avez installé un tunnel spécial pour le maître ou les autres esclaves. Dans le doute, laissez cette option vide.
--skip-slave-start Dit à l'esclave de ne pas lancer les threads esclaves au démarrage du serveur. L'utilisateur pourra les lancer manuellement, avec START SLAVE.
--slave_compressed_protocol=# Si cette option vaut 1, alors le protocole client/serveur compressé sera utilisé, si l'esclave et le maître le supportent.
--slave-load-tmpdir=filename Cette option vaut par défaut la variable tmpdir. Lorsque le thread SQL réplique des commandes LOAD DATA INFILE, il extrait les fichiers à charger du log de relais dans un fichier temporaire, puis charge ce fichier dans la table. Si le fichier chargé sur le maître est immense, le fichier temporaire sera aussi grand. Il faudra donc dire à l'esclave de placer ces fichiers temporaires sur un grand disque, qui sera différent de tmpdir: utilisez cette option. Dans ce cas, vous pouvez aussi utiliser l'option --relay-log, car les fichiers de log de relais seront aussi grands. --slave-load-tmpdir doit pointer sur un système de fichier basés sur un disque, et non pas sur une portion de mémoire: l'esclave doit pouvoir accéder à ce fichier pour répliquer la commande LOAD DATA INFILE, même après un redémarrage.
--slave-net-timeout=# Le nombre de secondes à attendre des données du maître, avant d'annuler la lecture en considérant que la connexion est rompue, et de tenter de se reconnecter. La première reconnexion intervient immédiatement après l'expiration du délai. L'intervalle entre deux tentatives de connexion est contrôlé par l'option --master-connect-retry.
--slave-skip-errors= [err_code1,err_code2,... | all] Normalement, la réplication s'arrête lorsqu'une erreur survient, ce qui vous donne l'opportunité de résoudre les incohérences manuellement. Cette option Indique au thread SQL les erreurs qu'il doit ignorer durant la réplication. N'utilisez pas cette option si vous ne connaissez pas la raison des erreurs que vous rencontrez. S'il n'y a pas de bugs dans votre réplication, et qu'il n'y a pas de bug dans MySQL, vous ne devriez pas rencontrer d'erreurs, ni utiliser cette option. L'utilisation abusive de cette option conduit irrémédiablement l'esclave à être désynchronisé avec le maître sans que vous ne sachiez d'où vient l'erreur.

   Pour les codes d'erreur, il faut utiliser les numéros d'erreurs fournis par l'esclave dans le log d'erreur, et dans le résultat de SHOW SLAVE STATUS. La liste complète des messages d'erreurs est disponible dans la distribution source, dans le fichier Docs/mysqld_error.txt.

Exemple de réplication

   Mysql permet de multiples configurations de réplication.

  Sur le maître

  Dans /etc/mysql/my.cnf ajouter:

log-bin les log-bin doivent être activés, c'est sur ces log que se base la réplication
id-server=1 ce numéro doit être unique à chaque serveur

on crée l'utilisateur pour la réplication
GRANT REPLICATION SLAVE ON generator.php TO replication@'server-B' identified by 'password'
puis on lock les tables
FLUSH TABLES WITH READ LOCK;
on note le fichier de log et sa position ; attention la valeur n'est valide que si log-bin est déjà activé, sinon utiliser les valeur par défaut
SHOW MASTER STATUS ;
on copie les tables que l'on souhaite répliquer pour les envoyer sur l'esclave. et on enlève le verrou
UNLOCK TABLES;
on peut relancer le serveur mysql
/etc/init.d/mysql restart

   Sur le serveur esclave :

  dans /etc/mysql/my.cnf, dans la section [mysqld] ajouter:

log-bin
id-server=2
skip-slave-start cette options sert pour éviter de prendre en compte les options de réplication puisque l'on va la lancer en ligne.
#master-host=server-B on laisse ces lignes commentée pour le premier démarrage.
#master-port=3306
#master-user=replication
#master-password=password
#master-connect-retry=60
#report-host=db-slave.uubu
#log-slave-updates n'est utile qu'en cas d'un modèle de réplication A › B › C. B joue alors le rôle de relay

on crée l'utilisateur pour la réplication
GRANT REPLICATION SLAVE ON generator.php TO replication@'server-A' identified by 'password'
on stop le serveur mysql
/etc/init.d/mysql stop
on copie les bases du master, bien vérifier les droits ! On relance le serveur mysql
/etc/init.d/mysql start
on lance la réplication
mysql› CHANGE MASTER TO
-› MASTER_HOST='server-A',
-› MASTER_USER='replication',
-› MASTER_PASSWORD='password',
le fichier de log qu'on a noté via SHOW MASTER STATUS
-› MASTER_LOG_FILE='‹recorded log file name›',
idem pour la position
-› MASTER_LOG_POS=‹recorded log offset› ;
puis lancement en tant qu'esclave
START SLAVE
ouvrir de nouveau /etc/mysql/my.cnf
on peut supprimer skip-slave-start puisque la réplication est en place, et décommenter les lignes qu'on avait ajouté en commentaire. Relancer le serveur
/etc/init.d/mysql restart

Explication de log-slave-updates

   Le serveur B se base sur le log-bin du serveur A pour répliquer les données. Par défaut, le serveur B ne log pas dans ses log-bin les données de réplication. Dans le cas où on souhaiterai ajouter un serveur C qui se réplique sur B, il est nécessaire d'ajouter cette options, afin que les données répliquées soient bien écrite dans les log-bin.

Autres exemple de réplication

   Le système est très souple, ici j'explique une réplication de type A › B + le principe pour une réplication en chaîne de type A › B › C.

  Il est bien sûr possible que B et C se répliquent tous 2 sur A directement.

  Il est même possible de créer une réplication croisée de type A‹›B. La manip n'est pas très différente, mais un peu plus délicate.

  Dans un premier temps il faut suivre l'exemple ci-dessus pour créer une réplication de A vers B. Ensuite reprendre l'exemple, locker les tables sur B, noter le log-bin et sa position, puis suivre l'exemple de B ci-dessus, et l'appliquer sur A : renseigner /etc/mysql/my.cnf, relancer le serveur, puis lancer la réplication.
^
08 mai 2010

htmlpdflatexmanmd




mysqladmin

mysqladmin

Utilitaire d'administation de MySQL

COMMANDES

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.
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 Éteins le serveur.
slave-start Démarre l'esclave de réplication.
status Affiche le message de statut court du serveur.
slave-stop Éteind l'esclave de réplication.
variables Affiche les variable disponibles.
version Affiche la version du serveur.

   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 secondes.
        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).

OPTIONS

--help, - ? Affiche le message d'aide et quitte.
--character-sets-dir=path Le dossier où les jeux de caractères sont stockés.
--compress, -C Compresse toutes les informations entre le client et le serveur, si les deux le supporte.
--count=#, -c # Le nombre d'itération à faire. 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.
--relative, -r Affiche la différence entre la valeur courante et la valeur précédente, lorsque 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 Affiche la sortie verticalement. Similaire à --relative, mais verticalement.
--wait[=#], -w[#] Si la connexion n'a pu être établie, attend et retente 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 expiration de connexion. (Par défaut, 0.)
        shutdown_timeout Le nombre de seconde d'attente de l'extinction. (Par défaut, 0.)
^
08 mai 2010

htmlpdflatexmanmd




mysqlbinlog

mysqlbinlog

Exécuter des requêtes dans les logs binaire

OPTIONS

--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 Commence la lecture dans le log binaire à la position N.
--protocol=TCP | SOCKET | PIPE | MEMORY Spécifie le protocole de connexion à utiliser.
--read-from-remote-server, -R Lit le log binaire depuis un serveur MySQL. 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.

Exemples

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
shell› mysqlbinlog hostname-bin.000001 | mysql
ou:
shell› mysqlbinlog hostname-bin.[0-9]* | mysql
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.
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"
^
08 mai 2010

htmlpdflatexmanmd




mysqlcheck

mysqlcheck, mysqlrepair, mysqlanalyze, mysqloptimize

Outil d'entretient et de réparation de tables MyISAM

   À la différence de myisamchk, mysqlcheck s'utilise lorsque mysqld fonctionne. Il y'a 3 façons de l'utiliser:

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

   mysqlcheck dispose l'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épare 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 qui change le mode par défaut 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

OPTIONS

-?, --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.
--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.
--extended, -e Si vous utilisez cette option avec CHECK TABLE, elle va s'assurer que la table est totalement cohérente, mais prends beaucoup de 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.
--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 Affiche des informations sur les différentes étapes.
--version, -V Affiche les informations de version, et termine
^
04 mai 2010

htmlpdflatexmanmd




mysqld

mysqld, mysqld-max, mysqld-safe, mysql.server, mysqld_multi

Serveur de base de donnée mysql

mysqld est le serveur MySQL
mysqld-max version du serveur qui inclut des fonctionnalités supplémentaires
mysqld-safe est un script de démarrage du serveur. Tente de démarrer mysqld-max s'il existe sinon mysqld.
mysql.server est un script de démarrage du serveur, utilisé sur les systèmes qui ont un dossier contenant des services système. Il invoque mysqld-safe pour démarrer le serveur.
mysqld_multi est un script de démarrage qui peut lancer ou arrêter différentes instances du serveur, installées sur le système.

mysqld-max est une version mysqld compilée avec des fonctionnalités supplémentaires.
MySQL AB compile le serveur SQL avec les options suivantes :

        --with-server-suffix=-max ajoute le suffixe -max à la chaîne de version mysqld
        --with-innodb active le support du moteur InnoDB.
        --with-bdb active le support du moteur de table Berkeley DB

   Pour connaître les moteurs de stockage que votre serveur supporte, utiliser la commande SHOW ENGINES; safe_mysqld est la méthode recommandée pour démarrer un démon mysqld. Il ajoute des fonctionnalités de sécurité telles que le redémarrage automatique lorsqu'une erreur survient et l'enregistrement d'informations d'exécution dans un fichier de log. Par défaut il essaie de lancer mysqld-max s'il existe. Pour remplacer le comportement par défaut et spécifier explicitement le serveur à utiliser, spécifier --mysqld ou --mysqld-version.

Options identique de mysql_safe et mysqld

--basedir=path Le chemin jusqu'à l'installation de MySQL.
--core-file-size=# Taille du fichier core que mysqld doit être capable de créer. Il est passé à ulimit -c.
--datadir=path Le chemin jusqu'au dossier de données.
--defaults-extra-file=path Le nom du fichier d'options à lire en plus des fichiers habituels.
--defaults-file=path Le nom d'un fichier d'options qui doit être lu à la place du fichier d'options habituel.
--err-log=path L'ancienne option --log-error, à utiliser avant MySQL 4.0.
--ledir=path Le chemin jusqu'au dossier contenant le dossier mysqld. Utilisez cette option pour indiquer explicitement le lieu du serveur.
--log-error=path Écrit le fichier d'erreurs dans le fichier
--mysqld=prog_name Le nom du programme serveur (dans le dossier ledir) que vous voulez lancer. Cette option est nécessaire si vous utilisez une distribution binaire MySQL, mais que les données sont hors du dossier d'installation.
--mysqld-version=suffix Cette option est similaire à l'option --mysqld, mais vous spécifiez uniquement le suffixe du nom du programme. Le nom de base sera alors mysqld. Par exemple, si vous utilisez --mysqld-version=max, mysqld_safe va lancer le programme mysqld-max dans le dossier ledir. Si l'argument de --mysqld-version est vide, mysqld_safe utilise mysqld dans le dossier ledir.
--nice=priority Utilise le programme nice pour donner la priorité du serveur.
--no-defaults Ne lit aucun fichier d'options.
--open-files-limit=count Le nombre de fichiers que mysqld ouvre au maximum. La valeur de l'option est passée à ulimit -n. Notez que vous devez lancer mysqld_safe en tant que root pour que cela fonctionne correctement.
--pid-file=path Le chemin jusqu'au fichier d'identifiant de processus.
--port=port_num Le numéro de port à utiliser pour attendre les connexion TCP/IP.
--socket=path Le fichier de socket Unix pour les connexions locales.
--timezone=zone Configure la variable d'environnement TZ. Consultez votre documentation système pour connaître le format légal des fuseaux horaires.
--user=user_name | user_id Lance le serveur mysqld sous le nom d'utilisateur user_name ou avec l'utilisateur d'identifiant numérique ID user_id. (``Utilisateur'' dans ce contexte représente le compte système, et non pas les utilisateurs des tables de droits MySQL).

   mysql.server est utilisé pour arrêter les services. Il lit les options dans les sections [mysql.server], [mysqld] et [mysql_server]

  mysqld_multi est un programme pour gérer plusieurs serveurs MySQL qui utilisent différents sockets Unix et ports TCP.

  

Options de mylsql_multi

--config-file=name Un fichier de configuration alternatif. Note : cela ne va pas modifier les options de ce programme ([mysqld_multi]), mais uniquement les groupes [mysqld#]. Sans cette option, tout sera lu dans le fichier d'options traditionnel my.cnf. Cette option n'affecte pas la façon avec laquelle mysqld_multi lit ses options, qui sont toujours prises dans le groupe [mysqld_multi] du fichier my.cnf habituel.
--example Affiche un exemple de fichier de configuration.
--help Affiche l'aide et quitte.
--log=name Fichier de log. Le chemin complet et le nom du fichier sont nécessaires.
--mysqladmin=prog_name L'exécutable mysqladmin à utiliser lors de l'arrêt du serveur.
--mysqld=prog_name L'exécutable mysqld à utiliser. Notez que vous pouvez donner cette option à safe_mysqld. Ces options sont passées à mysqld. Assurez-vous que vous avez bien mysqld dans votre variable d'environnement PATH ou corrigez safe_mysqld.
--no-log Affiche les données d'historique à l'écran plutôt que dans le fichier de log. Par défaut, le fichier de log est activé.
--password=password Le mot de passe de l'utilisateur mysqladmin.
--tcp-ip Connexion au serveur MySQL via le port TCP/IP au lieu de la socket Unix. Cela affecte l'arrêt et le rapport. Si le fichier de socket manque, le serveur peut continuer de tourner, mais il n'est plus accessible que par port TCP/IP. Par défaut, les connexions sont faites avec les sockets Unix.
--user=user_name L'utilisateur MySQL pour mysqladmin.
--version Affiche le numéro de version et quitte.

Options de ligne de commande de mysqld

   mysqld lit les options des groupes mysqld et server. Un serveur MySQL intégré lit les options des groupes server, embedded et xxxxx_SERVER, où xxxxx est le nom de l'application. Pour voir la liste complète des options de mysqld: mysqld --verbose --help

--allow-suspicious-udfs contrôle le fait que les options utilisateurs qui disposent d'un seul symbole puisse être chargé. Désactivé par défaut.
--ansi utilise la syntaxe ANSI SQL. Pour un contrôle plus précis utiliser l'option --sql-mode
--basedir=path, --b path chemin jusqu'au dossier d'installation
--big-tables autorise la sauvegarde de grands résultats dans des fichiers temporaires. Résout le problème des erreur "table full", mais ralentit les requêtes alors que des tables en mémoire suffirait.
--bind-address=IP l'adresse IP à utiliser
--console écrit les messages d'erreurs sur la sortie standard, même si --log-error est spécifié
--character-sets-dir=path dossier contenant les jeux de caractères
--chroot=path met le démon mysqld en environnement chroot au démarrage
--core-file Écrit le fichier core lorsque mysqld s'arrête inopinément. Pour certains fichier vous devez spécifier aussi --core-file-size à safe_mysqld
--datadir=path, -h path chemin jusqu'au dossier des données
--debug[=debug_options], -# [debug_options] si MySQL est configuré avec --with-debug permet d'obtenir un fichier de trace.
--default-character-set=character spécifie le jeu de caractères par défaut
--default-collation=collation spécifie la collation par défaut.
--default-storage-engine=type synonyme de --default-table-type
--default-table-type=type spécifie le type de table par défaut
--delay-key=write[= OFF | ON | ALL ] spécifie comment l'option DELAYED KEYS doit être utilisé.
--des-key-file=file_name lit les clés par défaut utilisés par DES_ENCRYPT() et DES_DECRYPT()
--exit-info, -T Cette option est la combinaison d'options que vous pouvez utiliser pour le débogage du serveur mysqld.
--external-locking Active le verrouillage système. Notez que si vous utilisez cette option sur un système pour qui lockd ne fonctionne pas (comme Linux), vous allez bloquer rapidement mysqld avec les verrous. Anciennement appelée --enable-locking.
--flush Écrit toutes les données sur le disque après chaque requête SQL. Normalement, MySQL fait des écritures sur le disque après chaque requête, et laisse le système d'exploitation assurer la synchronisation avec le disque.
--init-file=file Lit les commandes SQL dans ce fichier au démarrage. Chaque commande doit être sur une ligne, et ne pas utiliser de commentaires.
--language=lang_name, -L lang_name Spécifie la langue utilisée pour les messages d'erreur du client. Le chemin complet doit être utilisé.
--log[=file], -l [file] Enregistre les connexions et les requêtes dans ce fichier. Si vous ne le faites pas, MySQL va utiliser host_name.log comme nom de fichier.
--log-bin=[file] Enregistre toutes les requêtes qui modifient des données dans un log. Ce log est utilisé pour la sauvegarde et la réplication. Si vous ne le faites pas, MySQL va utiliser host_name-bin comme nom de fichier.
--log-bin-index[=file] Fichier d'index pour les noms de fichiers de log binaire. Si vous ne le faites pas, MySQL va utiliser host_name-bin.index comme nom de fichier.
--log-error[=file] Enregistre les messages d'erreurs et les messages de démarrage dans ce fichier Si vous ne le faites pas, MySQL va utiliser host_name.err comme nom de fichier.
--log-isam[=file] Enregistre toutes les modifications des tables ISAM/MyISAM dans ce fichier (uniquement nécessaire pour déboguer ISAM/MyISAM).
--log-long-format Enregistre des informations supplémentaires dans les fichiers de log (log de modifications, log binaire de modifications, log de requêtes lentes, n'importe quel log en fait). Par exemple, le nom d'utilisateur et un timestamp sont enregistrés avec la requête. Si vous utilisez --log-slow-queries et --log-long-format, alors les requêtes qui n'utilisent pas d'index seront aussi enregistrées. Notez que --log-long-format est obsolète depuis la version 4.1, où --log-short-format a été introduite (le format de log long est la configuration par défaut en version 4.1). Notez aussi que depuis la version MySQL 4.1 l'option --log-queries-not-using-indexes est disponible pour enregistrer spécifiquement les requête qui n'utilisent pas d'index, dans le log de requêtes lentes.
--log-queries-not-using-indexes Si vous utilisez cette option avec --log-slow-queries, alors les requêtes qui n'utilisent pas d'index seront aussi enregistrées dans le log de requêtes lentes.
--log-short-format Enregistre moins d'information dans les fichiers de log (log de modifications, log binaire de modifications, log de requêtes lentes, n'importe quel log en fait). Par exemple, les noms d'utilisateur et un timestamp ne seront pas enregistrés avec les requêtes.
--log-slow-queries[=file] Enregistre toutes les requêtes qui prennent plus de long_query_time secondes a s'exécuter.
--log-warnings, -W Affiche les alertes comme Aborted connection... dans le fichier d'erreur .err. Activer cette option est recommandé, par exemple, si vous utilisez la réplication : vous obtiendrez plus d'informations sur ce qui se passe, comme les erreurs de connexion réseau, ou les reconnexions.
--low-priority-updates Les opérations de modifications de table (INSERT/DELETE/UPDATE) auront une priorité inférieure aux sélections. Cela peut être aussi fait via l'attribut INSERT | REPLACE | UPDATE | DELETE LOW_PRIORITY ... pour baisser la priorité d'une requête, ou avec SET LOW_PRIORITY_UPDATES=1 pour changer la priorité dans plus d'un thread
--memlock Verrouille le processus mysqld en mémoire. Cela fonctionne si votre système support la fonction mlockall() (comme Solaris). Ceci peut être utile si vous avez des problèmes avec le système d'exploitation qui force mysqld à utiliser le swap sur le disque.
--myisam-recover [=option[,option...]]] Cette option est la combinaison de DEFAULT, BACKUP, FORCE et QUICK. Vous pouvez aussi lui donner la valeur explicite de "" si vous voulez désactiver cette option. Si cette option est utilisée, mysqld va vérifier si la table est marquée comme corrompue à l'ouverture de chaque table (cette dernière option ne fonctionne que si vous utilisez l'option --skip-external-locking). Si c'est le cas, mysqld va essayer de vérifier la table. Si la table était corrompue, mysqld essaie alors de la réparer.
--pid-file=path Le chemin jusqu'au fichier de PID utilisé par safe_mysqld.
--port=port_num, -P port_num Numéro de port utilisé pour attendre les connexion TCP/IP.
--old-protocol, -o Utilise le protocole 3.20, pour la compatibilité avec de très vieux clients.
--one-thread Utilise uniquement un thread (pour débogage sous Linux). Cette option est disponible uniquement si le serveur est compilé avec les options de débogage.
--open-files-limit=count Pour changer le nombre de pointeurs de fichiers disponibles pour mysqld. Si cette option n'est pas configurée, ou qu'elle vaut 0, alors mysqld va utiliser cette valeur pour réserver ce nombre de pointeurs de fichiers, à utiliser avec setrlimit(). Si la valeur est 0 alors mysqld va réserver max_connections*5 ou max_connections + table_cache*2 (le plus grand des deux) pointeurs de fichiers. Il est recommandé d'augmenter cette valeur si mysqld émet des erreurs de type 'Too many open files'.
--safe-mode Ignore certains étapes d'optimisation.
--safe-user-create Si cette option est activée, un utilisateur ne peut pas créer de nouveaux utilisateurs avec la commande GRANT si l'utilisateur n'a pas les droits de INSERT dans la table mysql.user ou dans aucune colonne de cette table.
--secure-auth Interdit l'identification des comptes qui ont des mots de passe ancien (avant la version 4.1).
--skip-bdb Désactive l'utilisation des tables BDB. Cela va économiser de la mémoire et accélérer le serveur un peu. N'utilisez pas cette option si vous avez besoin des tables BDB.
--skip-concurrent-insert Désactive la possibilité de sélectionner et insérer en même temps dans les tables MyISAM (cela n'est utile que si vous pensez que vous avez trouvé un bug dans cette fonctionnalité).
--skip-external-locking Ne pas utiliser le verrouillage du système. Pour utiliser les utilitaires isamchk ou myisamchk vous devez alors éteindre le système.
--skip-grant-tables Cette option force le serveur à ne pas utiliser le système de privilège du tout. Cela donne à tous l'accès complet à toutes les bases de données ! Vous pouvez demander à un serveur en exécution d'utiliser à nouveau les tables de droits en exécutant la commande mysqladmin flush-privileges ou mysqladmin reload).
--skip-host-cache Ne pas utiliser le cache de nom de domaine pour une résolution des IP plus rapide, mais interroger le serveur DNS à chaque connexion.
--skip-innodb Désactive l'utilisation des tables InnoDB. Cela va économiser de la mémoire et accélérer le serveur un peu. N'utilisez pas cette option si vous avez besoin des tables InnoDB.
--skip-isam Désactive l'utilisation des tables ISAM. Cela va économiser de la mémoire et accélérer le serveur un peu.
--skip-name-resolve Les noms d'hôtes ne sont pas résolus. Toutes les colonnes Host dans vos tables de droits doivent être des IP numériques ou le mot localhost
--skip-networking Ne pas attendre les connexions TCP/IP du tout. Toutes les interactions du serveur mysqld seront faites avec les sockets Unix. Cette option est particulièrement recommandée pour les systèmes qui utilisent des requêtes locales.
--skip-new Ne pas utiliser les nouvelles routines qui sont possiblement erronées.
--symbolic-links, --skip-symbolic-links Active ou désactive le support des liens symboliques. signifie que vous pouvez mettre un fichier d'index MyISAM ou un autre fichier de données dans un autre dossier, avec les options INDEX DIRECTORY ou DATA DIRECTORY de la commande CREATE TABLE. Si vous effacer ou renommez la table, les fichiers qui sont des liens symboliques seront aussi effacés ou renommés.
--skip-show-database Si MySQL est configuré avec --with-debug=full, tous les programmes vérifieront la mémoire pour rechercher les écrasements de zone lors des allocations et libérations de mémoire. Comme ce test est lent, vous pouvez l'éviter, si vous n'avez pas besoin de tester la mémoire, en utilisant cette option.
--skip-stack-trace Ne pas écrire les piles de traces. Cette option est pratique lorsque vous utilisez mysqld avec un débogueur. Sur certains systèmes, vous devez aussi utiliser cette option pour obtenir un fichier de core.
--skip-thread-priority Désactive les priorités des threads pour améliorer la vitesse de réponse.
--socket=path Sous Unix, le fichier de socket pour les connexions locales. (par défaut, /tmp/mysql.sock).
--sql-mode=value[,value[,value...]] Spécifie le mode SQL.
--temp-pool En utilisant cette option, vous allez réduire le jeu de noms qui sont utilisés lors de la création de fichier temporaires, plutôt qu'un nom unique à chaque fois. Ceci est un palliatif au noyau Linux qui crée plusieurs fichiers nouveaux avec des noms différents. Avec l'ancien comportement, Linux semble "perdre de la mémoire", car ils sont alloués au cache d'entrées du dossier au lieu de celui du disque.
--transaction-isolation=level Configure le niveau d'isolation des transactions. Le niveau peut être READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ ou SERIALIZABLE
--tmpdir=path, -t path Chemin vers les fichiers temporaires. Il peut s'avérer pratique si votre dossier par défaut /tmp réside dans une partition qui est trop petite pour absorber les tables temporaires. cette option accepte différents chemins, qui sont utilisés en alternance. Les chemins doivent être séparés par des deux points (‘ :’) sous Unix. Il est possible de dire à tmpdir de pointer sur un système de fichiers en mémoire, hormis si le serveur MySQL est un esclave. Si c'est un esclave, il faut un système de fichiers permanents (pour que la réplication des tables temporaires et des commandes LOAD DATA INFILE) survive a un redémarrage de la machine : un système de fichiers en mémoire tmpdir, qui est effacé au lancement de la machine n'est pas acceptable. Un disque est nécessaire pour tmpdir, dans ce contexte.
--user=user_name | user_id, -u user_name | user_id Éxécute le démon mysqld avec l'utilisateur user_name ou userid (numérique). (``utilisateur'' dans ce contexte fait référence à l'utilisateur du système d'exploitation, mais pas l'utilisateur MySQL, listé dans les tables de droits.) Cette option est obligatoire lorsque vous démarrez mysqld en tant que root. Le serveur va changer d'ID durant le lancement du serveur, pour utiliser un autre utilisateur que root.
--version, -V Affiche les informations de version.

   Pour éviter des trous de sécurité si un utilisateur ajoute --user=root dans un fichier my.cnf (et donc, faisant que le serveur fonctionne en tant que utilisateur système root), mysqld utilise uniquement la première option --user spécifiée, et produit une alerte s'il rencontre d'autres options --user. Les options des fichiers /etc/my.cnf et datadir/my.cnf sont traités avant les options de ligne de commande, et il est recommandé que vous ajoutiez l'option --user dans le fichier /etc/my.cnf puis spécifiez une valeur autre que root. L'option de /etc/my.cnf peut être placée avant toute autre option --user, ce qui assure que le serveur fonctionnera avec l'utilisateur autre que root, et qu'une alerte apparaîtra si une autre option --user est découverte.
^
08 mai 2010

htmlpdflatexmanmd




mysqldump

mysqldump

Utilitaire de sauvegarde des structures de tables de données

Plusieurs méthodes
shell› mysqldump [options] db_name [tables]
shell› mysqldump [options] --databases DB1 [DB2 DB3...]
shell› mysqldump [options] --all-databases

OPTIONS

--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).
--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.
--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.
--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.
--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 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.
--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 */;. 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.
--first-slave, -x Verrouille toutes les tables de toutes les bases de données.
--flush-logs, -F Écrit 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 exportez 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 la ligne /* !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 a é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.
--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.
--quick, -q Ne garde pas en buffer les requêtes, mais écrit immédiatement dans la sortie.
--quote-names, -Q Protège les noms des tables et colonnes avec le caractère ‘`’.
--result-file=file, -r file Écrit 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. 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 à --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؏" "-wuseridկ"
-X, --xml Exporte la base au format XML

Exemples

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
^
08 mai 2010

htmlpdflatexmanmd




mysqlhotcopy

mysqlhotcopy

Sauvegarde rapide des bases de données

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/

OPTIONS

--allowold Ne pas annuler si la sauvegarde existe déjà (renomme 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
^
08 mai 2010

htmlpdflatexmanmd




mysqlimport

mysqlimport

Utilitaire pour LOAD DATA INFILE

   La plupart des options correspondent.

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

  mysqlimport utilise de nom des fichiers sans les extensions pour nommer les tables.

OPTIONS

--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.
--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 est 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.
--replace, -r Les options --replace et --ignore contrôlent 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 sont ignorés. 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.
^
08 mai 2010

htmlpdflatexmanmd




mysqlshow

mysqlshow

Informations sur les bases, tables et colonnes

   mysqlshow fournis une interface pour de nombreuses déclarations SQL SHOW. Si le dernier argument contient des caractères *, ?, %, ou _, seul les noms qui match seront affichés.

OPTIONS

--bind-address=ip_address Permet de spécifier l'interface utilisé pour se connecter au serveur
--character-sets-dir=path dossier contenant les jeux de caractères
--compress, -C Compresse toutes les informations entre le client et le serveur, si c'est possible.
--count Affiche le nombre de lignes par table.
--debug[=debug_options], -# [debug_options] Écrit un log. une chaîne debug_options est généralement 'd:t:o,file_name'. Défaut: 'd:t:o'
--debug-check Affiche des informations de débuggage quand le programme se termine.
--debug-info Affiche des informations de mémoire et CPU quand le programme se termine.
--default-character-set=charset_name Utilise le jeu de caractère spécifié
--default-auth=plugin Plugin d'authentification côté client à utiliser
--host=host_name, -h host_name Nom du serveur MySQL à utiliser
--keys, -k Affiche les index de table
--password[=password], -p[password] Le mot de passe à utiliser lors de la connexion au serveur.
--plugin-dir=path Le répertoire où rechercher les plugins.
--port=port_num, -P port_num Le numéro de port TCP/IP pour la connexion.
--protocol={TCP|SOCKET|PIPE|MEMORY} Protocol de connexion à utiliser pour se connecter au serveur
--show-table-type, -t Affiche une colonne indiquant le type de table, comme dans SHOW FULL TABLES. le type est BASE TABLE ou VIEW
--socket=path, -S path Socket utilisée pour la connexion au serveur.
--ssl* Les options qui commencent par --ssl spécifient les paramètres de connexion en utilisant SSL
--status, -i Affiche des informations supplémentaire sur chaque table.
--user=user_name, -u user_name Nom d'utilisateur pour la connexion au serveur
--verbose, -v Mode détaillé. Affiche plus d'informations sur les faits et gestes du programme.
^
04 mai 2010

htmlpdflatexmanmd




MySQL - Moteurs de table

MySQL - Moteurs de table

Moteur de table et types de table

On peut créer une table en spécifiant la clause ENGINE ou TYPE:
CREATE TABLE t (i INT) ENGINE = INNODB ;
CREATE TABLE t (i INT) TYPE = MEMORY ;
si on omet cette clause, le moteur par défaut est utilisé, spécifié par la variable système table_type. Pour convertir une table d'un type à l'autre, utilisez la commande ALTER TABLE, pour indiquer le nouveau type:
ALTER TABLE t ENGINE = MYISAM ;
ALTER TABLE t TYPE = BDB ;

Moteur de table MyISAM

   Chaque table MyISAM est stockée en trois fichiers. Les fichiers portent le nom de la table, et ont une extension qui spécifie le type de fichier. Le fichier .frm stocke la définition de la table. L'index est stocké dans un fichier avec l'extension .MYI (MYIndex), et les données sont stockées dans un fichier avec l'extension .MYD (MYData).

- Toutes les clés numériques sont stockées avec l'octet de poids fort en premier, pour améliorer la compression.
- Support des grands fichiers
- Les lignes de taille dynamique sont bien moins fragmentées lors de l'utilisation d'insertion et d'effacement.
- Le nombre maximal d'index par table est de 64
- La taille maximale d'une clé est de 1000 octets
- Les colonnes BLOB et TEXT peuvent être indexées.
- Les valeurs NULL sont autorisées dans une colonne indexée. Elles prennent 0 à 1 octets par clé.
- Les fichiers d'index sont généralement plus petits en MyISAM qu'en ISAM.
- améliore l'utilisation d'espace dans l'arbre des clés.
- Vous pouvez placer les fichiers de données et d'index dans différents dossiers pour obtenir plus de vitesse avec les options de table DATA DIRECTORY et INDEX DIRECTORY, dans la commande CREATE TABLE.
- chaque colonne de caractères peut avoir un jeu de caractères distinct.
- Il y a un indicateur dans le fichier MyISAM qui indique si la table a été correctement fermée.
- myisampack peut compresser des colonnes BLOB et VARCHAR.
- Support du vrai type VARCHAR; une colonne VARCHAR commence avec une taille, stockée sur 2 octets.
- Les tables ayant des colonnes VARCHAR peuvent avoir un format de lignes fixe ou dynamique.
- VARCHAR et CHAR peuvent prendre jusqu'à 64 ko.
- Un index de hashage peut être utilisé avec UNIQUE. Cela vous permettra d'avoir un index UNIQUE sur toute combinaison de colonnes de la table. Vous ne pourrez pas utiliser un index UNIQUE pour une recherche.

   Les options suivantes de mysqld permettent de modifier le comportement des tables MyISAM:

--myisam-recover=mode Active le mode de restauration automatique des tables MyISAM corrompues.
--delay-key-write=ALL N'écrit pas les buffers de clés entre deux écritures dans une table MyISAM.

   Note: Si vous faîtes cela, vous ne devez pas utiliser les tables MyISAM avec d'autres programmes (comme depuis un autre serveur MySQL ou avec myisamchk) lorsque la table est utilisée. Sinon, vous allez obtenir une corruption d'index.

  Utiliser --external-locking n'aidera pas les tables qui utilisent --delay-key-write.

   Les variables systèmes suivantes affectent le comportement des tables MyISAM

bulk_insert_buffer_size La taille du cache d'index lors des insertions de masse. Note : c'est une limite par thread !
myisam_max_extra_sort_file_size Utilisée pour aider MySQL à décider quand utiliser le cache de clé lent mais sûr.
myisam_max_sort_file_size N'utilise pas la méthode de tri rapide pour créer un index, si un fichier temporaire dépasserait cette taille.
myisam_sort_buffer_size La taille du buffer lors de la restauration de table.

   La restauration automatique est activée si vous lancez mysqld avec l'option --myisam-recover. Dans ce cas, lorsque le serveur ouvre la table MyISAM, il vérifie si la table a été marquée comme crashée ou si le compteur de tables ouvertes n'est pas zéro ou si le serveur utilise --skip-external-locking. Si une des conditions précédente est vraie, il arrive ceci

- La table est analysée pour rechercher des erreurs.
- Si le serveur trouve une erreur, il essaie de faire une réparation rapide (avec le tri, sans recréer de données).
- Si la réparation échoue à cause d'une erreur dans le fichier de données (par exemple, une erreur de clé), le serveur essaie à nouveau, en re-créant le fichier de données.
- Si la réparation échoue encore, le serveur essaie encore avec une ancienne méthode réparation (écrire les lignes les unes après les autres, sans tri). Cette méthode devrait être capable de réparer tout les types d'erreurs, et elle occupe peu de place sur le disque.
- Si la restauration n'est toujours pas capable de retrouver toutes les lignes, et que vous n'avez pas spécifié l'option FORCE dans la valeur de l'option --myisam-recover, la réparation automatique s'annule, avec le message d'erreur suivant: Error : Couldn't repair table : test.g00pages
- Si vous spécifiez la valeur FORCE, une alerte comme celle-ci sera écrite dans les logs: Warning : Found 344 of 354 rows when repairing ./test/g00pages

   Notez que si la valeur de restauration automatique inclut BACKUP, le processus de restauration créera des fichiers avec des noms de la forme tbl_name-datetime.BAK. Vous devriez avoir une tâche régulière avec cron pour supprimer automatiquement ces fichiers dans les bases de données pour nettoyer le volume.

   Pour avoir une approximation de la taille du fichier d'index, faire la somme de (longueur_clef+4)/0.67 pour toutes les clefs. (c'est le pire des cas où les clefs sont insérées dans l'ordre et qu'aucune n'est compressée).

   MyISAM supporte 3 différents types de tables. Deux des trois sont choisis automatiquement selon le type de colonne que vous utilisez. Le troisième, tables compressées, ne peut être crée qu'avec l'outil myisampack. Quand vous créez une table avec CREATE ou en modifiez la structure avec ALTER vous pouvez, pour les tables n'ayant pas de champ BLOB forcer le type de table en DYNAMIC ou FIXED avec l'option ROW_FORMAT=# des tables. Bientôt, vous pourrez compresser/décompresser les tables en spécifiant ROW_FORMAT=compressed | default à ALTER TABLE.

   Tables statiques: Ceci est le format par défaut. Il est utilisé lorsque la table ne contient pas de colonnes de type VARCHAR, BLOB, ou TEXT. Ce format est le plus simple et le plus sûr. C'est aussi le format sur disque le plus rapide.

- Toutes les colonnes CHAR, NUMERIC, et DECIMAL sont complétées par des espaces jusqu'à atteindre la longueur totale de la colonne.
- Très rapide.
- Facile à mettre en cache.
- Facile à reconstruire après un crash, car les enregistrements sont localisés dans des positions fixées.
- N'a pas à être réorganisé (avec myisamchk) sauf si un grand nombre de lignes est effacé et que vous voulez retourner l'espace libéré au système d'exploitation.
- Requière généralement plus d'espace disque que les tables dynamiques.

   Tables à format de ligne dynamiques: Ce format est utilisé avec les tables qui contiennent des colonnes de type VARCHAR, BLOB ou TEXT, ou si la table a été créée avec l'option ROW_FORMAT=dynamic. Vous pouvez utiliser la commande SQL OPTIMIZE table ou Shell myisamchk pour défragmenter une table.

- Toutes les colonnes de type chaîne sont dynamiques (hormis celle qui sont de taille inférieure à 4).
- Chaque ligne est précédée d'un octet qui indique quelles sont les lignes vides ('', bit à 1) et celle qui le ne sont pas (bit à 0). Une colonne vide n'est pas la même choses qu'une colonne qui contient NULL. Si une colonne a une taille de zéro après avoir supprimé les espaces finaux, ou un nombre a une valeur de zéro, il est marqué dans cet octet, et la colonne sera ignorée sur le disque. Les chaînes non vides sont sauvées avec un octet de plus pour y stocker la taille.
- Ce format prend généralement moins de place que des tables à format fixe.
- Chaque ligne consomme autant d'espace que nécessaire. Si une ligne devient trop grande, elle sera coupée en blocs et écrites dans le fichier de données. Cela engendre la fragmentation du fichier de données. Dans ce cas, vous pouvez avoir à exécuter la commande myisamchk -r de temps en temps pour améliorer les performances. Utilisez myisamchk -ei tbl_name pour obtenir des statistiques.
- Ce format de table n'est pas toujours facile à reconstituer après un crash, car une ligne peut être fragmentée en de nombreux blocs, et un fragment peut manquer.

La taille d'une ligne de format variable se calcule avec
3
+ (nombre de colonnes + 7) / 8
+ (nombre de colonnes de tailles chars)
+ taille compactée des colonnes numériques
+ taille des chaînes
+ (nombre de colonne de valeur NULL + 7) / 8

- Il y a un aussi un supplément de 6 octets pour chaque lien. Une ligne de format dynamique utilise un lien à chaque fois qu'une modification cause un agrandissement de la ligne. Chaque nouveau bloc lié fait au moins 20 octets, pour que le prochain agrandissement utilise aussi ce bloc. Si ce n'est pas le cas, un nouveau bloc sera lié, avec un autre coût de 6 octets. Vous pouvez vérifier le nombre de liens dans une table avec la commande myisamchk -ed. Tous les liens sont supprimés avec la commande myisamchk -r.

   tables compressées: C'est un type en lecture seule qui est généré avec l'outil optionnel myisampack.

- Les tables compressées prennent très peu d'espace disque.
- Chaque ligne est compressée séparément (optimisation des accès). L'en-tête d'un enregistrement est fixé (1-3 octets) selon le plus grand enregistrement dans la table. Chaque colonne est compressée différemment. Quelques un des types de compressions sont:

        - Compression des espaces en suffixe.
        - Compression des espaces en préfixe.
        - Les nombres avec la valeur 0 sont stockés en utilisant 1 octet.
        - Si les valeurs dans une colonne de type entier ont un petit intervalle, la colonne est stockée en utilisant le type le plus petit possible.
        - Si une colonne n'a qu'un petit éventail de valeurs, son type est changé en ENUM.
        - Une colonne peut utiliser une combinaison des compressions précédentes.
        - Peut gérer les enregistrements de tailles fixes ou variables.

   Vous pouvez réparer une table corrompue avec REPAIR TABLE. Vous pouvez aussi réparer une table, lorsque mysqld ne fonctionne pas, avec la commande myisamchk

Tables assemblées MERGE

   Une table MERGE est un groupe de tables MyISAM identiques qui sont utilisées comme une seule. "Identique" signifie que toutes les tables ont la même structure de colonnes et d'index

Tables MEMORY (HEAP)

   Le moteur de stockage MEMORY crée des tables dont le contenu est stocké en mémoire.

- Vous pouvez avoir des clés non-uniques dans une table MEMORY. (C'est une fonctionnalité rare pour les index hash).
- Si vous avez un index hash sur une table HEAP avec un haut degré de duplication (de nombreux valeurs d'index contiennent la même valeur), les modifications dans cette table peuvent affecter les valeurs des clés et toutes les suppressions seront plus lentes. Le facteur de ralentissement est proportionnel au degré de duplication (ou inversement proportionnel à la cardinalité).
- Les tables HEAP utilisent un format de ligne fixe.
- HEAP ne supporte pas les colonnes de type BLOB/TEXT.
- HEAP ne supporte pas les colonnes de type AUTO_INCREMENT.
- Les tables HEAP sont partagées entre tous les clients (comme une autre table).
- La caractéristique des tables MEMORY qui fait que les tables sont stockées en mémoire est partagée avec les tables internes que le serveur crée à la volée lors du traitement des requêtes. Cependant, les tables internes ont aussi la capacité d'être converties en tables disques automatiquement, si elles deviennent trop grandes. La taille limite est déterminée par la valeur de tmp_table_size.

   Les tables MEMORY ne peuvent pas être converties en tables disques. Pour vous assurer que vous ne faîtes rien de dangereux pour le serveur, vous pouvez utiliser la variable système max_heap_table_size pour imposer une taille maximale aux tables MEMORY. Pour des tables individuelles, vous pouvez utiliser l'option de table MAX_ROWS avec la commande CREATE TABLE.

- Vous avez besoin de suffisamment de mémoire pour accepter toutes les tables HEAP que vous allez utiliser simultanément.
- Pour libérer de la mémoire, vous devez exécuter la commande DELETE FROM heap_table, TRUNCATE heap_table ou DROP TABLE heap_table.
- Si vous voulez remplir les tables MEMORY au lancement du serveur MySQL, vous pouvez utiliser l'option --init-file. Par exemple, vous pouvez mettre les commandes telles que INSERT INTO ... SELECT et LOAD DATA INFILE pour lire des données dans une source de données persistante.
- Si vous utilisez la réplication, les tables MEMORY du maître se vident à l'extinction. Cependant, un esclave peut ne pas s'apercevoir que ces tables ont été vidées, et il risque de retourner des données invalides si vous l'utilisez. lorsqu'une table MEMORY est utilisée sur le maître, il émet une commande DELETE FROM automatiquement, pour synchroniser l'esclave et le maître. Notez que même avec cette stratégie, l'esclave aura des données obsolètes entre le moment où le maître s'éteint et celui où il est redémarré. Mais si vous utilisez l'option --init-file pour remplir la table MEMORY au lancement du serveur, elle s'assurera que cette intervalle est bien null.

La mémoire nécessaire pour les tables HEAP sont
SUM_OVER_ALL_KEYS(max_length_of_key + sizeof(char*) * 2)
+ ALIGN(length_of_row+1, sizeof(char*))

ALIGN() représente un facteur d'arrondi, car la taille de la ligne doit faire exactement un multiple de la taille du pointeur de char. sizeof(char*) vaut 4 sur les machines 32 bits et 8 sur une machine 64 bits.

Tables BDB ou BerkeleyDB

   En utilisant les tables BDB, vos tables ont plus de chances de survivre aux crashs, et vous avez accès à COMMIT et ROLLBACK avec les transactions. Les options suivantes de mysqld peuvent être utilisées pour modifier le comportement des tables BDB:

--bdb-home=répertoire Répertoire de base des tables BDB. Cela doit être le même répertoire que vous avez utilisés pour --datadir.
--bdb-lock-detect=# Détection des verrouillages Berkeley. (DEFAULT, OLDEST, RANDOM, ou YOUNGEST).
--bdb-logdir=répertoire Répertoire des fichiers de log de Berkeley DB.
--bdb-no-recover Ne pas démarrer Berkeley DB en mode de restauration.
--bdb-no-sync Ne pas vider les tampons synchroniquement.
--bdb-shared-data Démarrer Berkeley DB en mode multi-processus (Ne pas utiliser DB_PRIVATE lors de l'initialisation de Berkeley DB)
--bdb-tmpdir=répertoire Répertoire des fichiers temporaires de Berkeley DB.
--skip-bdb Désactive l'utilisation des tables BDB.

   Les variables systèmes suivante affectent le comportement des tables BDB. bdb_max_lock est le nombre maximal de verrous actifs sur une table BDB. Si vous utilisez --skip-bdb, MySQL n'initialisera pas la bibliothèque Berkeley DB et cela économisera beaucoup de mémoire. Bien sûr, vous ne pouvez pas utiliser les table BDB si vous utilisez cette option. Si vous essayez de créer une table BDB, MySQL créera une table MyISAM à la place.

   Normalement, vous devez démarrer mysqld sans --bdb-no-recover si vous avez l'intention d'utiliser des tables BDB. Cela peut cependant vous poser des problèmes si vous essayez de démarrer mysqld alors que des fichiers de log BDB sont corrompus. Vous pouvez spécifier le nombre maximal de verrous avec bdb_max_lock (10000 par défaut) que vous pouvez activer sur une table BDB. Vous devez l'augmenter si vous obtenez des erreurs du type: bdb : Lock table is out of available locks Got error 12 from ... lorsque vous avez fait de longues transactions ou quand mysqld doit examiner beaucoup de lignes pour calculer la requête. Vous pouvez aussi changer les options binlog_cache_size et max_binlog_cache_size si vous utilisez de grandes transactions multi-lignes.

Moteur de table EXAMPLE

   C'est un moteur "bidon" qui ne fait rien du tout. Son but est de fournir des exemples au niveau du code source de MySQL pour illustrer l'écriture d'un moteur de table. En tant que tel, il intéressera surtout les développeurs.

Moteur de table FEDERATED

   C'est un moteur de table qui accède à des tables dans une base de données distante, plutôt que dans des fichiers locaux.

Moteur de table ARCHIVE

   Il est utilisé pour stocker de grande quantité de données, sans index, et de manière très économique. Le moteur ARCHIVE ne supporte que les commandes INSERT et SELECT: aucun effacement, remplacement ou modification. Une commande SELECT effectue un scan de table complet. Les enregistrements sont compressés au moment de leur insertion. Vous pouvez utiliser la commande OPTIMIZE TABLE pour analyser la table, et compresser encore plus.

Moteur CSV

   Ce moteur stocke les données dans un fichier texte, avec le format valeurs séparées par des virgules.

Moteur de table InnoDB

   InnoDB fournit à MySQL un gestionnaire de table transactionnelle (compatible ACID), avec validation (commits), annulations (rollback) et capacités de restauration après crash. InnoDB utilise un verrouillage de lignes, et fournit des lectures cohérentes comme Oracle, sans verrous. Ces fonctionnalités accroissent les possibilités d'utilisation simultanées des tables, et les performances. Il n'y a pas de problème de queue de verrous avec InnoDB, car les verrous de lignes utilisent très peu de place. Les tables InnoDB sont les premières tables MySQL qui supportent les contraintes de clés étrangères (FOREIGN KEY).

   Si vous ne souhaitez pas utiliser les tables InnoDB, vous pouvez ajouter l'option skip-innodb dans votre fichier d'options MySQL. Les deux ressources disques importantes gérées par InnoDB sont sa table de données et son fichier de log. Si vous ne spécifiez aucune options de configuration InnoDB, MySQL créera un fichier de données auto-croissant appelé ibdata1 et deux fichiers de log de 5 Mo appelés ib_logfile0 et ib_logfile1 dans le dossier de données MySQL.

Pour configurer le fichier de données InnoDB, utilisez l'option innodb_data_file_path dans my.cnf:
innodb_data_file_path=datafile_spec1[ ;datafile_spec2]...

Exemples

Cette configuration crée un fichier de données de 10 Mo ibdata1, auto-croissant. Il n'y a pas de dossier de sauvegarde d'indiqué: par défaut, c'est le dossier de données de MySQL.
[mysqld]
innodb_data_file_path=ibdata1:10M:autoextend
Une table contenant 50 Mo de données, appelée ibdata1 et un fichier 50 Mo auto-croissant, appelé ibdata2 dans le dossier de données
[mysqld]
innodb_data_file_path=ibdata1:50M ;ibdata2:50M:autoextend
La syntaxe complète de la spécification de fichier de données inclut le nom du fichier, sa taille, et différents attributs:
file_name:file_size[:autoextend[:max:max_file_size]]
[mysqld]
innodb_data_file_path=ibdata1:10M:autoextend:max:500M
La ligne de configuration suivante permet au fichier ibdata1 de croître jusqu'à 500 Mo
[mysqld]
innodb_data_home_dir = /ibdata
innodb_data_file_path=ibdata1:50M ;ibdata2:50M:autoextend
crée deux fichiers appelés ibdata1 et ibdata2 mais les place dans le dossier /ibdata,
!!!!Note : InnoDB ne crée pas les dossiers
Si vous spécifier l'option innodb_data_home_dir sous forme de chaîne vide, vous pouvez spécifier des noms de chemins absolus dans la valeur de innodb_data_file_path. L'exemple ci-dessous est équivalent au précédent:
[mysqld]
innodb_data_home_dir =
innodb_data_file_path=/ibdata/ibdata1:50M ;/ibdata/ibdata2:50M:autoextend

Exemple de configuration
[mysqld]
# Vous pouvez placer d'autres options MYSQL ici
# ...
# Le fichier de données doit contenir vos données et index.
# Assurez vous que vous avez l'espace disque nécessaire.
innodb_data_file_path = ibdata1:10M:autoextend
#
# Utilisez un buffer de taille 50 à 80 % de votre mémoire serveur
set-variable = innodb_buffer_pool_size=70M
set-variable = innodb_additional_mem_pool_size=10M
#
# Utilisez un fichier de log de taille 25 % du buffer mémoire
set-variable = innodb_log_file_size=20M
set-variable = innodb_log_buffer_size=8M
#
innodb_flush_log_at_trx_commit=1

Options de démarrage InnoDB

innodb_additional_mem_pool_size La taille du buffer mémoire d'InnoDB, pour ses dictionnaires d'informations, et ses structures internes de données. Une valeur pratique est 2Mo, mais plus vous aurez de tables dans votre application, plus vous devrez augmenter cette valeur. Si InnoDB est à court de mémoire, il va allouer de la mémoire auprès du système, et écrire des messages dans le fichier de logs.
innodb_buffer_pool_size La taille de buffer mémoire que InnoDB utiliser pour mettre en cache les données et les index de tables. Plus cette valeur est grand, et moins vous ferez d'accès disques. Sur un serveur dédiés, vous pouvez monter cette valeur jusqu'à 80% de la mémoire physique de la machine. Ne lui donnez pas une valeur trop grande, car cela peut engendrer l'utilisation de mémoire sur le disque par votre serveur.
innodb_data_file_path Chemin individuel vers les fichiers de données, et leur taille. Le chemin complet de chaque fichier de données est créé en concaténant innodb_data_home_dir avec les chemins spécifiés ici. La taille du fichier est spécifiée en méga-octets, ce qui explique la présence du 'M' après les spécifications ci-dessus. Vous pouvez donner au fichier une taille supérieure à 4 Go sur les systèmes d'exploitation qui acceptent les gros fichiers.
Sur certains systèmes, la taille doit être inférieure à 2 Go.Si vous ne spécifiez pas innodb_data_file_path, le comportement par défaut est de créer un fichier auto-croissant de 10 Mo, appelé ibdata1. vous pouvez donner une taille de fichier de plus de 4Go sur les systèmes d'exploitation qui supportent les grands fichiers. Vous pouvez aussi utiliser les partition raw.
innodb_data_home_dir La partie commune du chemin de tous les fichiers de données InnoDB. Si vous ne mentionnez pas cette option, la valeur par défaut sera celle du dossier de données MySQL. Vous pouvez aussi spécifier une chaîne vide, et dans ce cas, les chemins spécifiés dans innodb_data_file_path seront des chemins absolus.
innodb_fast_shutdown Par défaut, InnoDB fait une purge complète et vide le buffer d'insertion avant une extinction. Ces opérations peuvent prendre beaucoup de temps. Si vous donnez à ce paramètre la valeur de 1, InnoDB ignore ces opérations d'extinction. Sa valeur par défaut est 1.
innodb_file_io_threads Nombre de pointeurs de fichier de InnoDB. Normalement, cette valeur doit être de 4.
innodb_file_per_table Cette option fait que InnoDB va stocker chaque table dans un fichier .ibd indépendant. Voyez la section sur les espaces de tables multiples.
innodb_flush_log_at_trx_commit Normalement, cette option vaut 1, ce qui signifie que lors de la validation de la transaction, les logs sont écrits sur le disque, et les modifications faites par la transaction deviennent permanentes, et survivront un crash de base. Si vous souhaitez réduire la sécurité de vos données, et que vous exécutez de petites transactions, vous pouvez donner une valeur de 0 à cette option, pour réduire les accès disques.
innodb_flush_method La valeur par défaut pour cette option est fdatasync. Une autre option est O_DSYNC.
innodb_force_recovery Attention : cette option ne doit être définie que dans les cas où vous voulez exporter les données d'une base corrompue, dans une situation d'urgence. Les valeurs possibles de cette option vont de 1 à 6. Par mesure de sécurité, InnoDB empêche les modifications de données si la valeur de cette option est supérieure à 0.
innodb_lock_wait_timeout Le délai d'expiration des transactions InnoDB, en cas de blocage de verrou, avant d'annuler. InnoDB détecte automatiquement les blocages de verrous et annule alors les transactions. Si vous utilisez la commande LOCK TABLES, ou un autre gestionnaire de table transactionnelles que InnoDB dans la même transaction, un blocage de verrou peut survenir, et InnoDB ne pourra pas le détecter. Ce délai est donc pratique pour résoudre ces situations.
innodb_log_arch_dir Le dossier où les logs complétés doivent être archivés, si nous utilisons l'archivage de logs. La valeur de ce paramètre doit être actuellement la même que la valeur de innodb_log_group_home_dir.
innodb_log_archive Cette valeur doit être actuellement de 0. Au moment de la restauration de données à partir d'une sauvegarde, à l'aide des log binaires de MySQL, il n'y a actuellement pas besoin d'archiver les fichiers de log InnoDB.
innodb_log_buffer_size La taille du buffer que InnoDB utilise pour écrire les log dans les fichiers de logs, sur le disque. Les valeurs utiles vont de 1 Mo à 8 Mo. Un grand buffer de log permet aux grandes transactions de s'exécuter sans avoir à écrire de données dans le fichier de log jusqu'à la validation. Par conséquent, si vous avez de grandes transactions, augmenter cette taille va réduire les accès disques.
innodb_log_file_size Taille de chaque fichier de log dans un groupe de log, exprimé en méga-octets. Les valeurs pratiques vont de 1Mo à une fraction de la taille du buffer de log (1 / le nombre de logs, en fait). Plus la taille est grande, moins de points de contrôles seront utilisés, réduisant les accès disques. La taille combinée des logs doit être inférieure à 4 Go sur les systèmes 32 bits.
innodb_log_files_in_group Nombre de fichiers de logs dans le groupe de log. InnoDB écrit dans ces fichiers de manière circulaire. Une valeur de 2 est recommandée. C'est la valeur par défaut.
innodb_log_group_home_dir Le dossier pour les fichiers de logs. Il doit avoir la même valeur que innodb_log_arch_dir. Si vous ne spécifiez pas de paramètre de log InnoDB, la configuration par défaut va créer deux fichiers de logs de 5 Mo, appelés ib_logfile0 et ib_logfile1 dans le dossier de données MySQL.
innodb_max_dirty_pages_pct Cette entier va de 0 à 100. Par défaut, il vaut 90. Le thread principal de InnoDB essaie de transmettre les pages au pool de buffer, pour qu'un pourcentage maximal de innodb_max_dirty_pages_pct soit encore en attente de flush. Si vous avez le droit de SUPER, ce pourcentage peut être changée durant l'exécution du serveur:SET GLOBAL innodb_max_dirty_pages_pct = value ;
innodb_mirrored_log_groups Nombre de copies identiques de groupe de log que nous conservons. Actuellement, cette valeur doit être au minimum de 1.
innodb_open_files Ce n'est utile que si vous utilisez les espaces de tables multiples. Cette option spécifie que le nombre maximal de fichier .ibd que InnoDB peut garder ouvert simultanément. La valeur minimum est de 10. La valeur maximum est de 300.
Les pointeurs de fichiers utilisés par .ibd sont réservés pour InnoDB. Ils sont indépendants de ceux spécifiés par —open-files-limit, et n'affectent pas les opérations de cache. innodb_thread_concurrency
InnoDB essaie de garder le nombre de thread système concurents inférieur à la limite de ce paramètre. La valeur par défaut est 8. Si vous avez des problèmes de performances, et que SHOW INNODB STATUS revèle que des threads attendent des sémaphores, essayez de diminuer ou augmenter ce paramètre. Si vous avez un serveur avec de nombreux processeurs et disques,
vous pouvez essayer d'augmenter la valeur, pour utiliser au mieux les ressources disponibles. Une valeur recommandée est la somme du nombre de processeurs et de disques que vous avez. Une valeur de 500 ou supérieur, supprime la vérification de concurrence.

Créer des bases InnoDB

utiliser TYPE = InnoDB. ex:
CREATE TABLE CUSTOMER (A INT, B CHAR (20), INDEX (A)) TYPE = InnoDB ;
La quantité d'espace disponible apparaît dans la section de commentaire de la commande SHOW. Par exemple:
SHOW TABLE STATUS FROM test LIKE 'CUSTOMER'
vous pouvez désactiver l'auto-validation avec la commande SET AUTOCOMMIT = 0 et utiliser les commandes COMMIT et ROLLBACK pour valider ou annuler vos transactions. Si vous voulez laisser le mode d'auto-validation tranquille, vous pouvez placer vos commandes entre START TRANSACTION et COMMIT ou ROLLBACK.

Convertir des tables MyIsam vers InnoDB

   pour utiliser le moteur InnoDB pour la création de table par défaut, utiliser default-table-type=innodb dans le groupe [mysqld]. Le moyen le plus rapide pour mettre la table au format InnoDB est d'insérer directement les lignes dans une table InnoDB, c'est à dire, utiliser ALTER TABLE ... TYPE=INNODB, ou créer un table InnoDB vide, avec la même définition et de faire l'insertion de toutes les lignes avec INSERT INTO ... SELECT * FROM ....

INSERT INTO newtable SELECT * FROM oldtable
WHERE yourkey › something AND yourkey ‹= somethingelse ;
Une fois que toutes les données ont été insérées dans la table, vous pouvez la renommer.

   Colonnes AUTO_INCREMENT avec InnoDB: Innodb va ajouter dans le dictionnaire de données un compteur spécial appelé compteur auto-increment, qui est utilisé pour assigner les nouvelles valeurs de la colonne.

   Contraintes de clés étrangères FOREIGN KEY: La syntaxe des définitions de contraintes de clés étrangères de InnoDB est la suivante:

[CONSTRAINT symbol] FOREIGN KEY [id] (index_col_name, ...)
REFERENCES tbl_name (index_col_name, ...)
[ON DELETE CASCADE | SET NULL | NO ACTION | RESTRICT]
[ON UPDATE CASCADE | SET NULL | NO ACTION | RESTRICT]

   Les deux tables doivent être de type InnoDB, dans la table, il doit y avoir un INDEX où les clés étrangères sont listées comme première colonne, dans le même ordre, et dans la table référencée, il doit y avoir un INDEX où les colonnes référencées sont listées comme premières colonnes, dans le même ordre. Les préfixes d'index ne sont pas supportés pour les clés de contrainte.

exemple:
CREATE TABLE parent(id INT NOT NULL,
PRIMARY KEY (id)
) TYPE=INNODB ;
CREATE TABLE child(id INT, parent_id INT,
INDEX par_ind (parent_id),
FOREIGN KEY (parent_id) REFERENCES parent(id)
ON DELETE CASCADE
) TYPE=INNODB ;
exemple plus complexe :
CREATE TABLE product (category INT NOT NULL, id INT NOT NULL,
price DECIMAL,
PRIMARY KEY(category, id)) TYPE=INNODB ;
CREATE TABLE customer (id INT NOT NULL,
PRIMARY KEY (id)) TYPE=INNODB ;
CREATE TABLE product_order (no INT NOT NULL AUTO_INCREMENT,
product_category INT NOT NULL,
product_id INT NOT NULL,
customer_id INT NOT NULL,
PRIMARY KEY(no),
INDEX (product_category, product_id),
FOREIGN KEY (product_category, product_id)
REFERENCES product(category, id)
ON UPDATE CASCADE ON DELETE RESTRICT,
INDEX (customer_id),
FOREIGN KEY (customer_id)
REFERENCES customer(id)) TYPE=INNODB ;

InnoDB et la réplication

   Il est aussi possible d'utiliser la réplication pour que les tables de l'esclave ne soient pas les mêmes que les tables du maître. Par exemple, vous pouvez répliquer les modifications d'une table InnoDB sur le maître dans une table MyISAM sur l'esclave. Pour configurer un nouvel esclave sur le maître, vous devez faire une copie de l'espace de table InnoDB, des fichiers de log, ainsi que les fichiers .frm des tables InnoDB, et les placer sur l'esclave. Il y a des limitations mineures à la réplication InnoDB: LOAD TABLE FROM MASTER ne fonctionne pas pour les tables InnoDB. Il y a des palliatifs: 1) exportez la table du maître, et envoyez la sur l'esclave, ou, 2) utilisez ALTER TABLE tbl_name TYPE=MyISAM sur le maître avant de configurer la réplication avec LOAD TABLE tbl_name FROM MASTER, et ensuite, ALTER TABLE pour remettre les tables en mode InnoDB après cela.
^
08 mai 2010

htmlpdflatexmanmd




perror

perror

Expliquer les codes d'erreur

   Pour la plupart des erreurs système, MySQL affiche en plus d'un message texte, le code d'erreur système dans le style suivant:

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

   perror affiche une description pour le code d'erreur système ou pour le moteur de stockage.

Exemples

shell› perror 13 64
OS error code 13: Permission denied
OS error code 64: Machine is not on the network
Pour obtenir le message d'erreur pour un cluster MySQL
shell› perror --ndb errorcode

OPTIONS

--help, --info, -I, -? Affiche l'aide
--ndb Utilisé pour les codes d'erreur d'un cluster MySQL
--silent, -s mode silencieux, seules les erreurs seront affichées
--verbose, -v Mode détaillé. Affiche plus d'informations sur les faits et gestes du programme.
^
08 mai 2010

htmlpdflatexmanmd




replace

replace

Utilitaire de remplacement de chaîne dans les fichiers ou sur la sortie standard

shell› replace from to [from to] ... -- file_name [file_name] ...
shell› replace from to [from to] ... ‹ file_name

   from représente une chaîne à rechercher et to représente son remplacement. Cela peut être une ou plusieurs paires de chaînes. L'option -- indique où la liste de remplacement se termine et où le nom du fichier commence. replace affiche un message indiquant quel fichier il modifie actuellement.

Exemples

replace peut être utilisé pour inverser des chaînes. Par exemple, pour inverser a et b dans des fichiers donnés:
replace a b b a -- file1 file2 ...

OPTIONS

-#debug_options Active le débuggage
-s Mode silencieux
-v Augmente la verbosité