http://dasini.net/blog/presentations/?#presentation_mysql51

PDF à télécharger

mysqlslap : un utilitaire de test de charge et de performance

Disponible depuis MySQL 5.1.4, mysqlslap permet d’effectuer des tests de stress et de charge sur votre serveur MySQL. Vous pourrez alors tester les performances de votre SGBDR préféré, après, par exemple, une nouvelle installation, un changement d’architecture ou après avoir modifié des paramètres de configuration.

Créé pour devenir le meilleur ami des administrateurs de bases de données et des développeurs, le client mysqlslap envoie des requêtes au serveur MySQL en créant plusieurs connexions simultanées. A la fin de la simulation, un rapport de diagnostic est crée sur la sortie standard. Vous avez aussi la possibilité de l’écrire dans un fichier au format CSV utilisable directement avec Calc d’OpenOffice ou Excel de Microsoft.

Exemple d’utilisation de mysqlslap avec les options suivantes :

• user, password, socket : autentification classique d’un client MySQL,
• concurrency : nombre de clients effectuant simultanément une requête SELECT,
• iterations : nombre d’itérations du test à faire,
• number-of-queries : nombre total de requêtes effectuées lors du test,
• engine : moteur(s) à utiliser,
• auto-generate-sql : mysqlslap génère automatiquement un jeu de tests,
• number-int-cols : nombre de colonnes de type INT à créer,
• number-char-cols : nombre de colonnes de type CHAR à créer,
• auto-generate-sql-load-type : permet de spécifier le type de requêtes (lecture, insertion, lecture sur la clé primaire, mise à jour ou mixte)

Tests de performances avec des tables MyISAM et innoDB:

shell> mysqlslap --user=daz --password --socket=/tmp/mysql51.sock
--concurrency=1,100   --iterations=10  --number-of-queries=1000
--engine=myisam,innodb   --auto-generate-sql  --number-int-cols=2
--number-char-cols=3   --auto-generate-sql-load-type=mixed


Benchmark
   Running for engine myisam
   Average number of seconds to run all queries: 1.576 seconds
   Minimum number of seconds to run all queries: 1.539 seconds
   Maximum number of seconds to run all queries: 1.631 seconds
   Number of clients running queries: 1
   Average number of queries per client: 1000
Benchmark
   Running for engine myisam
   Average number of seconds to run all queries: 1.792 seconds
   Minimum number of seconds to run all queries: 1.543 seconds
   Maximum number of seconds to run all queries: 2.107 seconds
   Number of clients running queries: 100
   Average number of queries per client: 10
Benchmark
   Running for engine innodb
   Average number of seconds to run all queries: 2.477 seconds
   Minimum number of seconds to run all queries: 2.430 seconds
   Maximum number of seconds to run all queries: 2.663 seconds
   Number of clients running queries: 1
   Average number of queries per client: 1000
Benchmark
   Running for engine innodb
   Average number of seconds to run all queries: 2.704 seconds
   Minimum number of seconds to run all queries: 0.725 seconds
   Maximum number of seconds to run all queries: 5.272 seconds
   Number of clients running queries: 100
   Average number of queries per client: 10

Conclusion

Toujours aussi performant, fiable et robuste, certes un peu moins simple à administrer mais tellement plus riche, cette nouvelle version de MySQL devrait faire le bonheur des administrateurs de bases de données et des développeurs. Nous espérons que cet article vous a mis l’eau à la bouche et vous donnons d’ors et déjà rendez-vous au prochain numéro pour explorer plus en détail le partitionnement de MySQL.

Les nouveautés de MySQL 5.1 — (part 1/5)

Le moteur de stockage CSV

Le moteur de stockage CSV n’est pas une vraie nouveauté. Il est disponible depuis MySQL 4.1.4 (MySQL 5.1 pour M.S. Windows). Sa particularité est de stocker les données dans un fichier texte au format CSV (Comma Separated Values) où les données sont séparées par une virgule. Les avantages sont multiples, comme la possibilité d’éditer les données avec un éditeur de texte ou un tableur(Open Office Calc, Excel…) ou encore la possibilité de charger simplement d’énormes volumes de données dans le serveur MySQL.

Créer sa table au format CSV est très simple. On reste dans la logique MySQL de création de table : il faut en fait simplement spécifier CSV comme moteur (il n’est pas possible d’avoir des index, ni du partitionnement).

Pour créer une table au format CSV:

CREATE TABLE t_csv (
   id int, nom CHAR(50),
   prenom CHAR(50)
) ENGINE=CSV;

Le support de XML/XPath

A partir de MySQL version 5.1.5, un support basique de XML est implémenté sous la forme de deux fonctions: ExtractValue et UpdateXML.

• ExtractValue permet d’extraire les valeurs des différentes balises,

• UpdateXML permet de modifier la sortie d’un document XML.

Quelques exemples d’utilisation de ces deux fonctions avec la table t_xml et le fichier XML suivant (contenu dans le champ texte de la table t_xml)

Fichier XML et la table t_xml:

<?xml version="1.0" encoding="ISO-8859-1"?>
<profil>
   <formation categorie="MySQL" nbr_formation="5">
      <formateur>Olivier DASINI</formateur>
      <formateur>Pierre DUMONT</formateur>
      <Entreprise>Anaska</Entreprise>
   </formation>
   <formation categorie="PHP" nbr_formation="5">
      <formateur>Olivier DASINI</formateur>
      <formateur>Cyril PIERRE DE GEYER</formateur>
      <formateur>Romain BOURDON</formateur>
      <formateur>Julien PAULI</formateur>
      <Entreprise>Anaska</Entreprise>
   </formation>
   <formation categorie="Linux" nbr_formation="10">
      <formateur>Pierre DUMONT</formateur>
      <formateur>Fabien ALLARD</formateur>
      <Entreprise>Anaska</Entreprise>
   </formation>
   <formation categorie="Open Office" nbr_formation="3">
      <formateur>Sarah HAIM</formateur>
      <Entreprise>Anaska</Entreprise>
   </formation>
</profil>

CREATE TABLE t_xml (
   id int(11) NOT NULL AUTO_INCREMENT,
   texte text,
   PRIMARY KEY (id)
) ENGINE=MyISAM;

Pour avoir la liste des formateurs :

mysql> SELECT EXTRACTVALUE(texte,'/profil/formation/formateur') AS result FROM
t_xml\G
*************************** 1. row ***************************
result: Olivier DASINI Pierre DUMONT Olivier DASINI Cyril PIERRE DE GEYER Romain
BOURDON Julien PAULI Pierre DUMONT Fabien ALLARD Sarah HAIM
1 row in set (0.00 sec)

Récupérer seulement les formateurs MySQL :

mysql>SELECT  EXTRACTVALUE(texte,'/profil/formation[contains(@categorie,"MySQL")
]/formateur') AS result FROM t_xml\G
*************************** 1. row ***************************
result: Olivier DASINI Pierre DUMONT
1 row in set (0.09 sec)

Remplacer <formateur>Olivier DASINI</formateur> par <formateur>Freshdaz</formateur>

mysql> SELECT UPDATEXML('<profil><formation categorie="MySQL" nbr_formation="5">
<formateur>Olivier DASINI</formateur><formateur>Pierre DUMONT</formateur>
</formation></profil>', '/profil/formation/formateur[contains(.,"Olivier")]'
, '<formateur>Freshdaz</formateur>') AS result\G
*************************** 1. row ***************************
result: <profil><formation categorie="MySQL" nbr_formation="5">
<formateur>Freshdaz</formateur><formateur>Pierre DUMONT</formateur>
</formation></profil>
1 row in set (0.00 sec)

(à suivre… mysqlslap)

]]> http://dasini.net/blog/2008/12/13/les-nouveautes-de-mysql-51-part-45/feed/ 1 http://dasini.net/blog/2008/12/06/les-nouveautes-de-mysql-51-part-35/ http://dasini.net/blog/2008/12/06/les-nouveautes-de-mysql-51-part-35/#comments Fri, 05 Dec 2008 23:27:07 +0000 freshdaz http://dasini.net/blog/?p=295
(<- précédent)

MySQL Cluster : support des données sur disque

MySQL propose une solution de haute disponibilité : MySQL Cluster. Cette technologie permet de mettre en place une architecture cluster shared nothing à l’aide de tables au format NDBCluster. Jusqu’à MySQL 5.0, MySQL Cluster ne fonctionnait qu’entièrement en mémoire. Ceci excluait donc certaines bases de données trop volumineuses. La nouvelle version 5.1 lève cette limitation en permettant de mettre les données sur disque.

Pour enregistrer ses données sur le disque, il faut au préalable définir deux nouveaux objets : un LOGFILE GROUP et un TABLESPACE.

LOGFILE GROUP : permet gérer les undo log et le crash-recovery

Pour créer un logfile group:

CREATE LOGFILE GROUP lg_1
   ADD UNDOFILE 'undo_1.dat'
   INITIAL_SIZE 16M
   UNDO_BUFFER_SIZE 2M
   ENGINE NDB;
ALTER LOGFILE GROUP lg_1
   ADD UNDOFILE 'undo_2.dat'
   INITIAL_SIZE 12M
   ENGINE NDB;

TABLESPACE : pour stocker les données. A noter que le tablespace utilise le logfile group créé

On peut maintenant créer la table et l’associer au tablespace

Création d’un tablespace:

CREATE TABLESPACE ts_1
   ADD DATAFILE 'data_1.dat'
   USE LOGFILE GROUP lg_1
   INITIAL_SIZE 32M
   ENGINE NDB;
ALTER TABLESPACE ts_1
   ADD DATAFILE 'data_2.dat'
   INITIAL_SIZE 48M
   ENGINE NDB;

Création d’une table au format NDBCluster avec données sur disque:

CREATE TABLE 'City' (
   'ID' int(11) NOT NULL AUTO_INCREMENT,
   'Name' char(35) NOT NULL DEFAULT '',
   'Population' int(11) NOT NULL DEFAULT '0',
   PRIMARY KEY ('ID')
) TABLESPACE ts_1
   STORAGE DISK
   ENGINE=NDB;

Les tables de journalisation

MySQL offre la possibilité de journaliser l’activité du serveur. en activant le general log. Il est aussi est possible de journaliser seulement les requêtes lentes (celles qui s’exécutent en un temps supérieur au seuil que vous aurez préalablement fixé) en activant le slow_query_log.

MySQL 5.1 permet toujours de journaliser ces informations dans un fichier, et ajoute la possibilité de le faire en plus dans une table.

Cerise sur le gâteau, la journalisation peut être démarrée ou arrêtée à chaud.

Les commandes SHOW VARIABLES LIKE ‘general_log’ et SHOW VARIABLES LIKE ‘log_output’ permettent, respectivement, de savoir si le general_log est activé et sous quelle forme.

Pour afficher l’état du general_log:

mysql> SHOW VARIABLES LIKE 'general_log';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| general_log   | OFF   |
+---------------+-------+
1 row in set (0.03 sec)

mysql> SHOW VARIABLES LIKE 'log_output';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_output    | TABLE |
+---------------+-------+

Le general_log peut être activé dynamiquement avec la commande SET :

mysql> SET GLOBAL general_log = 1;
Query OK, 0 rows affected (0.04 sec)

Le format de sortie peut lui aussi être changé dynamiquement :

+---------------------+-------------------------+-----------+-----------
+--------------+---------------------------------------+
| event_time          | user_host               | thread_id | server_id
| command_type | argument                              |
+---------------------+-------------------------+-----------+-----------
+--------------+---------------------------------------+
| 2008-02-21 15:51:06 | daz[daz] @ localhost [] |        10 |        51
| Query        | SET GLOBAL log_output = ‘TABLE, FILE' |
| 2008-02-21 15:51:06 | daz[daz] @ localhost [] |        10 |        51
| Query        | SELECT * FROM mysql.general_log       |
+---------------------+-------------------------+-----------+-----------
+--------------+---------------------------------------+
2 rows in set (0.00 sec)

mysql> SET GLOBAL log_output = 'TABLE,FILE';
Query OK, 0 rows affected (0.00 sec)

Les mêmes opérations sont possibles sur le slow_query_log :

mysql> SHOW VARIABLES LIKE 'slow_query_log';
+----------------+-------+
| Variable_name | Value  |
+----------------+-------+
| slow_query_log | ON    |
+----------------+-------+
1 row in set (0.00 sec)

mysql> SELECT * FROM mysql.slow_log;
+------------+----------------------+-----------+-----------+---------------+-----+
| start_time | user_host query_time | lock_time | rows_sent | rows_examined | db |
      | last_insert_id | insert_id | server_id | sql_text
-----------------------------------------------------------------------------------
| 2008-02-21 15:57:13 | daz[daz] @ localhost [] | 00:00:00 | 00:00:00 | 0 | 0 |
      | test | 0 | 0 | 51 | SELECT * FROM mysql.slow_log |
| 2008-02-21 15:57:38 | daz[daz] @ 640m [192.168.1.106] | 00:00:00 | 00:00:00 | 268 |
      | 268 | mysql | 0 | 0 | 51 | SELECT * FROM information_schema.
      GLOBAL_VARIABLES G |
| 2008-02-21 15:57:43 | daz[daz] @ localhost [] | 00:00:00 | 00:00:00 | 2 | 2 | test |
      | 0 | 0 | 51 | SELECT * FROM mysql.slow_log |
+------------------------------------------------------------------------------------+
3 rows in set (0.00 sec)

(à suivre… Le moteur de stockage CSV & Le support de XML/XPath)

]]> http://dasini.net/blog/2008/12/06/les-nouveautes-de-mysql-51-part-35/feed/ 2 http://dasini.net/blog/2008/12/03/les-nouveautes-de-mysql-51-part-25/ http://dasini.net/blog/2008/12/03/les-nouveautes-de-mysql-51-part-25/#comments Wed, 03 Dec 2008 00:37:25 +0000 freshdaz http://dasini.net/blog/?p=275
(<- précédent)

Le programmateur d’évènements

Pouvoir automatiser ses tâches de manière fiable et simple est le rêve de tout administrateur de base de données. Le programmateur d’évènements (Event Scheduler) est un planificateur de tâches (CRON-like) embarqué dans MySQL 5.1.

Il est alors possible d’exécuter, de façon récurrente ou unique, des requêtes, en fonction de la date et de l’heure.

L’évènement se crée avec la commande CREATE EVENT.

CREATE EVENT nom_evenement ON SCHEDULE
      <moment> DO <code_sql>

L’évènement peut être lancé une seule fois (AT) ou de manière répétitive (EVERY)

<moment> = AT | EVERY

L’évènement est constitué d’un ensemble de requêtes.

<code_sql> = requêtes sql

Créer une vue matérialisée rafraîchie toutes les 10 minutes :

DELIMITER //
CREATE EVENT vue_materialisee
ON SCHEDULE EVERY 10 MINUTE
DO
BEGIN
   TRUNCATE TABLE _event.City_fra;
   INSERT INTO _event.City_fra
      SELECT * FROM world.City WHERE CountryCode='FRA'
      ORDER BY name;
END//
DELIMITER ;

La réplication par les données (row based)

MySQL permet de journaliser dans un fichier les requêtes d’écriture effectuées sur le serveur. Ce fichier, le binary log, stocke ces requêtes en un format binaire (d’où son nom). Il est indispensable à la réplication, et est également utilisé pour la restauration du serveur.

A partir de MySQL 5.1, le serveur permet de stocker cette information, non plus seulement sous forme de requêtes (statement based) mais également sous forme de lignes (row based). Cette nouvelle fonctionnalité est intéressante, en particulier en cas de réplication de requêtes non déterministes.

La commande SHOW VARIABLES LIKE ‘binlog_format’ permet de connaître le format du journal binaire

mysql> SHOW VARIABLES LIKE 'binlog_format';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| binlog_format | MIXED |
+---------------+-------+
1 row in set (0.00 sec)

Trois options de journalisation sont disponibles :

• Statement based (mode par défaut) : On journalise la requête telle-quelle (pas son résultat),
• Row based : On journalise le résultat de la requête,
• Mixed : MySQL choisit entre statement et row en fonction du contexte.

Le mode de journalisation peut être changé dynamiquement avec la commande SET

mysql> SET SESSION binlog_format='ROW';
Query OK, 0 rows affected (0.00 sec)

mysql> SHOW VARIABLES LIKE 'binlog_format';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| binlog_format | ROW   |
+---------------+-------+
1 row in set (0.01 sec)

mysql> SET SESSION binlog_format='STATEMENT';
Query OK, 0 rows affected (0.00 sec)

mysql> SHOW VARIABLES LIKE 'binlog_format';
+---------------+-----------+
| Variable_name | Value     |
+---------------+-----------+
| binlog_format | STATEMENT |
+---------------+-----------+
1 row in set (0.01 sec)

mysql> SET SESSION binlog_format='MIXED';
Query OK, 0 rows affected (0.00 sec)

mysql> SHOW VARIABLES LIKE 'binlog_format';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| binlog_format | MIXED |
+---------------+-------+
1 row in set (0.01 sec)

(à suivre… MySQL Cluster & general log, slow query log dans une table)

]]> http://dasini.net/blog/2008/12/03/les-nouveautes-de-mysql-51-part-25/feed/ 2 http://dasini.net/blog/2008/11/28/les-nouveautes-de-mysql-51-part-15/ http://dasini.net/blog/2008/11/28/les-nouveautes-de-mysql-51-part-15/#comments Fri, 28 Nov 2008 10:10:32 +0000 freshdaz http://dasini.net/blog/?p=237 Que de chemin parcouru depuis ce 5 juillet 1999, date de lancement de MySQL 3.23.0. En plus des objectifs de simplicité d’administration, de hautes performances et de fiabilité, se sont greffées, au fur et à mesure, les fonctionnalités les plus demandées par les utilisateurs. La nouvelle version du SGBDR open-source le plus utilisé, sortie en GA le jeudi 27 novembre 2008, ne déroge pas à ces règles d’or. Numéro un pour les applications en ligne, MySQL se positionne maintenant sur le secteur des applications d’entrepôts de données et d’informatique décisionnelle.

Le but de cet article est de brasser un large panorama des principales nouveautés de MySQL 5.1, telles que le partitionnement, le programmateur d’évènements, la réplication par les données, ainsi que le support des données sur disque avec MySQL Cluster et le support xml/xpath.

Le partitionnement

Une des fonctionnalités phare de cette nouvelle mouture, est la possibilité de partitionner ses tables MySQL. Le partitionnement consiste à fragmenter une table en fonction des données qu’elle contient. Le but principal est d’optimiser les performances : le partitionnement peut permettre d’améliorer les réponses de certaines requêtes. Les données étant stockées dans différentes partitions, l’optimiseur ne prendra pas en compte les partitions non impactées par la requête (PRUNING).

Un autre objectif est de faciliter certaines tâches de maintenance : les données d’une partition peuvent être facilement et rapidement effacées, simplement en supprimant la partition.

Enfin, le partitionnement permet de mettre les données et les index sur des disques différents : il est possible de stocker les données et les index sur des disques séparés, pour les tables MyISAM.

Le partitionnement avec MySQL

La commande SHOW VARIABLES LIKE ‘have_partitioning’ est un moyen simple de savoir si votre version de MySQL supporte le partitionnement.

mysql> SHOW VARIABLES LIKE 'have_partitioning';
+-------------------+-------+
| Variable_name     | Value |
+-------------------+-------+
| have_partitioning | YES   |
+-------------------+-------+
1 row in set (0.10 sec)

L’opération de partitionnement proprement dite se réalise lors de la création de la table (avec la commande CREATE TABLE) ou lors de la modification de sa structure (avec la commande ALTER TABLE) en utilisant la clause PARTITION BY.

CREATE TABLE ... ENGINE = <engine>
      PARTITION BY <type> ( <expression> )

Il est a noter que les moteurs Merge, Federated, CSV ne permettent pas le partitionnement.

<engine> = MyIsam | InnoDB | Archive | Falcon | NDBCluster | Memory

MySQL propose 4 types de partitionnement, par intervalle (RANGE), par liste (LIST), et par hachage (HASH ou KEY).

<type> = RANGE | LIST | HASH | KEY

Quelques exemples de partitionnements

Partitionner sa table est une opération très simple. Le plus délicat est finalement de savoir pourquoi partitionner et comment le faire. Le critère de partitionnement est donc essentiel pour espérer gagner en performance.

-- Partitionnement par intervalle
CREATE TABLE 'City_part_range' (
   'ID' int(11) NOT NULL AUTO_INCREMENT,
   'Population' int(11) NOT NULL DEFAULT '0',  KEY 'ID' ('ID')
) ENGINE=MyISAM
   PARTITION BY RANGE (population) (
   PARTITION p0 VALUES LESS THAN (100),
   PARTITION p1 VALUES LESS THAN (1000),
   PARTITION p2 VALUES LESS THAN (10000),
   PARTITION p3 VALUES LESS THAN (100000),
   PARTITION p4 VALUES LESS THAN (1000000),
   PARTITION p5 VALUES LESS THAN MAXVALUE
);

-- Partitionnement par liste
CREATE TABLE 'Country_part_list' (
   'Code' char(3) NOT NULL DEFAULT '',
   'Continent' tinyint UNSIGNED DEFAULT 1,
   KEY ('Code')
) ENGINE=MEMORY
   PARTITION BY LIST(Continent) (
   PARTITION pCateg1 VALUES IN (1),
   PARTITION pCateg2 VALUES IN (4),
   PARTITION pCateg3 VALUES IN (2,6),
   PARTITION pCateg4 VALUES IN (3,5,7)
);

-- Partitionnement par hash
CREATE TABLE 'City_part_hash' (
   'ID' int(11) NOT NULL AUTO_INCREMENT,
   'Name' char(35) NOT NULL DEFAULT '',
   'CountryCode' char(3) NOT NULL DEFAULT '',
   'District' char(20) NOT NULL DEFAULT '',
   'Population' int(11) NOT NULL DEFAULT '0',
   PRIMARY KEY ('ID')
) ENGINE=InnoDB PARTITION BY HASH (id) PARTITIONS 4;

-- Partitionnement par key
CREATE TABLE 'City_part_key' (
   'ID' int(11) NOT NULL AUTO_INCREMENT,
   'Name' char(35) NOT NULL DEFAULT '',
   'CountryCode' char(3) NOT NULL DEFAULT '',
   'District' char(20) NOT NULL DEFAULT '',
   'Population' int(11) NOT NULL DEFAULT '0',
   PRIMARY KEY ('ID')
) ENGINE=Archive PARTITION BY KEY () PARTITIONS 6;

(à suivre... event scheduler & row based Replication)

]]> http://dasini.net/blog/2008/11/28/les-nouveautes-de-mysql-51-part-15/feed/ 3 http://dasini.net/blog/2008/11/27/mysql-server-5130-ga-release/ http://dasini.net/blog/2008/11/27/mysql-server-5130-ga-release/#comments Thu, 27 Nov 2008 10:45:04 +0000 freshdaz http://dasini.net/blog/?p=227 Enfin !

MySQL 5.1 est enfin disponible pour la production

Parmi les nouveautés:

MySQL 5.1 provides a number of new enhancements including:

- Le partitionnement
- La réplication Row-based
- Les events scheduler
- Amélioration du support XML et XPath

…

http://dasini.net/blog/2008/11/28/les-nouveautes-de-mysql-51-part-15/

http://dev.mysql.com/downloads/