Configurer Aptana pour connecter des bases de données MySql

Utiliser Aptana comme IDE PHP est super mais devoir systématiquement changer de fenêtre de travail pour afficher PhpMyadmin et vérifier la structure des tables Mysql devient vite lassant (même si [CMD + TAB] ou [CTRL + TAB] rendent la chose un peu plus aisée). Dans ce cadre, il pourrait être utile de configurer une connection MySql sous Aptana.

Cet article présente la configuration sous Mac OSx 10.6 avec MAMP. Mais vous pourriez aisément configurer Aptana de la même manière avec une solution LAMP (sous Linux) ou WAMP (sous Windows).

Pour cette configuration, vous aurez besoin du MySql Connector/J driver que vous trouverez sur http://www.mysql.com/downloads/connector/j/. Téléchargez-le et décompressez-le dans le répertoire /Mamp/Library/share/Mysql/Connectors/.

1. Installer le plugin Sql Explorer pour Aptana

Tout d’abord, vous devrez installer le plugin Sql Explorer plugin pour Aptana : Sélectionnez le Menu Help / Install Software, puis cliquez sur le bouton « Add » pour ajouter un site source pour l’installation du plugin. Donnez-lui un nom (MySql) et l’emplacement suivant : http://eclipsesql.sourceforge.net/

Puis sélectionnez le site source nouvellement créé de la liste déroulante et cochez « SQL Explorer » avant de cliquer sur le bouton « finish » :

Add download site for Sql Explorer

2. Créer une connexion MySql

Ouvrez Aptana et sélectionnez le Menu Window / Open perspective / Other / SQL Explorer. Puis sélectionnez le menu Window / Showview / Connections pour créer une nouvelle connexion à MySql :

Window - Showview - Connections (create a MySql connection)

Cliquez sur le bouton « Create new connection profile » pour configurer le driver MySql : Create new database connection profile et afficher :

Configure Mysql connection

Donnez un nom à votre connexion : Mysql

Puis cliquez sur « Add/Edit drivers », et affichez le contenu de « SQL Explorer » dans le menu de gauche et cliquez sur « JDBC Drivers » puis sélectionnez « MySql Driver »:

Edit MySql driver

Choisissez le bouton « Copy » pour éditer les préférences d’une copie du MySql Driver et donnez un nom à votre driver (My MySql driver) :

Editing Mysql driver

Editez l’example URL comme suit :

jdbc:mysql://localhost:3306/

Vous devrez aussi changer le port puisque le port 3306 est le port de connexion MySql par défaut. Ouvrez MAMP et cliquez sur Preferences / Ports :

Checking MAMP MySql connection port

puis changez l’example URL du driver MySql :

jdbc:mysql://localhost:8889/

Cliquez ensuite sur le bouton « Extra class path » pour ajouter le MySql Connector/J driver (fichier mysql-connector-java-5.1.14-bin.jar) que vous trouverez dans /Mamp/Library/share/Mysql/Connectors/.

et complétez le Driver class name comme suit :

com.mysql.jdbc.Driver

Votre bopite de dialogue de Préférences driver devrait ressembler à ceci :

Mysql driver preferences

Cliquez « OK ». Aptana montre que votre driver a été correctement configuré :

Mysql driver correctly configured

Cliquez « OK » pour sélectionner « My MySql Driver » pour la connexion courante :

Dans la boîte de dialogue « Create new connection profile », sélectionnez le driver MySql nouvellement créé (My Mysql Driver) dans la liste déroulante. Cochez « auto logon » et saisissez le username et password root MySql :

Set MySql username and password

puis cliquez « OK ». Votre connexion est maintenant prête :

MySql connection ready

Opérez un clic droit sur votre connexion « Mysql » pour visualiser les structures de vos bases de données :

View Database structures

Serveurs Web locaux

Un développeur web travaillant sur un serveur Linux comme OpenSuse devra simplement activer et configurer Apache, MySql et le support PHP pour faire fonctionner ses sites Web dynamiques.

Si vous travaillez sur une station Windows, vous devrez installer une application Serveur Web pour exécuter vos scripts PHP.

Il y a quelques années, je travaillais avec EasyPhp, qui a un temps cessé d’évoluer. J’ai donc à l’époque changé de solution et choisi WampServer, qui est toujours la solution que j’utilise actuellement. Il est livré avec Apache, Mysql, Phpmyadmin (scripts php pour la gestion de vos bases de données). Il est facile à installer et propose des versions PHP et MySql à jour.

J’ai récemment découvert ZMWS. ZazouMiniWebServer qui est un logiciel serveur Web autonome qui peut être installé sous Windows. Il est livré avec PHP4 et PHP5 mais vous pourriez y ajouter des handlers qui le feront tourner en ASP, PERL,… :

Je l’ai testé aisément sur une clé USB comme serveur Web portable.

Vous pourriez aussi distribuer votre projet Web PHP sur CD et disposer ainsi d’un site web dynamique auto-navigable.

Le site de du projet Open Source ZMWS vous fournira aussi un forum et une documentation.

Webliography :

ZazouMiniWebServer

WampServer

Normalisation de base de données

La normalisation de base de données offre un lot de principes faciles à appliquer. Ils aideront le développeur à structurer sa base de données et améliorer les performances MySql.

Normaliser une base de données revient à organiser les données de manière plus efficace, logique, grâce à des règles normales, des principes normaux (qui donnent une norme). Pour plus d’efficacité, le processus de normalisation résultera en la construction de tables et de relations entre ces tables. La normalisation de base de données offre :

  • une structure optimisée qui ne gâche pas l’espace disque (la même donnée ne devrait pas être trouvée dans plus d’une table pour des raisons évidentes : la mise à jour de plusieurs tables pour la même donnée est absurde)
  • des dépendances logiques (implique l’enregistrement des données pertinentes à l’intérieur de ou en relation à la bonne table)

Les Formes Normales

Je me concentrerai ici sur les 3 premières règles, que les spécialistes appellent formes normales. Ces règles devraient ajouter suffisamment d’efficacité à votre base de données. Gardez en mémoire qu’il est parfois préférable de ne pas appliquer une règle (et donc d’interrompre la normalisation) pour des raisons pratiques. En effet, la normalisation consiste en l’ajout de tables de relation (qui créent un lien entre d’autres tables), par exemple, qui nécessiteront un changement par le développeur de ses requêtes MySql.

Les formes normales doivent être appliquées dans l’ordre : une normalisation avancée ne peut se produire que dans le cas où les règles précédentes de normalisation ont déjà été appliquées.

Pour une meilleure compréhension, je prends l’exemple d’une base de données discographique qui enregistre les albums d’artistes célèbres.

Créer la base de données à froid sans expérience de normalisation résulterait en la création d’une seule table :

records_table :

record_ID : 1 (defini comme Primary_KEY)

artist : Fleetwood Mac est un groupe américano-britannique formé en 1967…

record_title : The pious bird of good omen

record_style : Blues, Rock, Pop

record_label : blue horizon

record_release : 1969

Avec cette table simpliste, vous comprendrez aisément que :

  • une requête SELECT ne peut obtenir de l’information à propos d’un artiste sans connaître un record_ID
  • une requête UPDATE qui veut modifier la biographie d’un artiste devra le faire dans chaque ligne de la table associée à l’artiste en question
  • une requête DELETE effacera l’information concernant l’album ainsi que l’information concernant l’artiste

Ces limitations produiront des anomalies comme la corruption de données, des problèmes de ressource MySql (à cause des sous-requêtes LIKE),… Il est donc temps de normaliser cette base et nous le ferons grâce à la théorie relationnelle.

La Théorie relationnelle

1NF => La première Forme Normale : la forme atomique

Chaque champ de table devrait avoir une valeur atomique, c’est-à-dire une seule valeur dans la colonne de votre table. Dans l’exemple ci-dessus, les champs ‘record_artist’ et ‘record_style’ contiennent plus qu’une seule valeur. L’application de la 1NF résultera en la création de 2 tables supplémentaires :

records_table :

record_ID : 1 (defini comme Primary_KEY)

record_title : The pious bird of good omen

record_release : 1969

and

artists_table :

artist_ID : 1 (defini as Primary Key)

artist_name : Fleetwood Mac

artist_bio : Fleetwood Mac est un groupe américano-britannique formé en 1967

et

styles_table (avec 3 entrées) :

style_ID : 1 (defini comme Primary Key)

style_name : blues

style_ID : 2

style_name : pop

style_ID : 3

style_name : rock

Il est maintenant facile d’ajoute run artiste sans devoir ajouter un album pour cet artiste, vous pouvez effacer un album sans pour autant effacer l’information concernant l’artiste,…

Les données sont maintenant séparées dans des tables différentes. Il faut maintenant créer les liens, relations entre ces tables. Les relations de base de données peuvent être du type suivant :

1 à 1 : un élément de la table A correspond à un élément de la table B et cet élément de la table B correspond à un seul élément de la table A

1 à N : un enregistrement de la records_table n’est associé qu’à un seul label mais ce label peut être associé à un nombre illimité d’enregistrements de la table records_table. Dans ce cas, nous ajouterons une clef étrangère à la table records table contenant le label_ID

N à N : un enregistrement de la records_table peut être associé à plus d’un artiste et un artiste de la artists_table peut être associé à plus d’un enregistrement de la records_table. Dans ce cas, nous créerons une table supplémentaire appelée records_artists_table, une table de relation qui liera la records_table avec la artists_table

Ajoutons une clef étrangère à la records_table pour la gestion des label_ID:

records_table : relation 1 à N

record_ID : 1 (defini comme Primary_KEY)

record_title : The pious bird of good omen

record_release : 1969

label_ID : 1

avec la table des labels associée :

labels_table :

label_ID : 1 (défini comme PRIMARY KEY)

label_name : Blue horizon

et créons la nouvelle table :

records_artists_table : relation N à N

record_ID : 1 (clef primaire définie sur les 2 champs)

artist_ID : 1 (clef primaire définie sur les 2 champs)

Nous pourrions définir le même genre de relation entre la table records_table et les styles de musique :

records_styles_table : relation N à N

record_ID : 1 (clef primaire définie sur les 2 champs)

style_ID : 1 (clef primaire définie sur les 2 champs)

2NF => la seconde Forme Normale : les relations aux clefs

Cette Forme Normale s’assure que les colonnes qui ne sont pas définies comme clef dépendent strictement de la clef primaire. Ainsi, dans le cas d’une clef composite (une ligne de la table est identifiée grâce au record_ID et au author_ID), toutes les colonnes non définies comme clef doivent dépendre des 2 champs, etpas seulement à l’une d’entre elles. Imaginez la structure suivante :

records_reviews table :

record_ID : 1 (defined as primary key with the following field)

author_ID : 1 (defined as primary key with the previous field)

review : This compilation album is one of my favourites…

author_website : http://www.domain.com

Dans l’exemple ci-dessus, le champ ‘author_website’ ne dépend pas strictement de la clef composite record_ID-author_ID. Il dépend uniquement de l’author_ID. Appliquer la seconde forme normale revient à déplacer le champ author_website field vers la table authors_table.

3NF => la troisième Forme Normale

Avec la troisième forme normale, chaque champ doit dépendre de la clef primaire. Ainsi, un champ qui dépend d’une autre colonne que la clef primaire viole la 3è Forme Normale. Les adresses dans une table en sont un bon exemple. Imaginez la structure suivante :
labels_table :
label_ID : 1 (primary key)
label_name : Blue Horizon
label_zip : 1770
label_city : Sherborn
label_state : MA
Dans cette table, les champs label_city et label_state dépendent strictement du champ label_zip, et pas de la clef primaire label_ID. Pour rendre cette table conforme à la 3NF, créez la zip_table :
zip_table :
zip_ID : 1770 (primary key)
zip_city : Sherborn
zip_state : MA
Puis la table des labels ressemblera à :
labels_table :
label_ID : 1 (primary key)
label_name : Blue Horizon
zip_ID : 1770
Vous pourriez encore considérer que le champ zip_state nécessite la création d’une table spécifique :
states_table :
state_ID : 1 (primary key)
state_name : MA
La normalisation telle qu’exposée plus haut vous permet de créer des structures de base de données propres mais implique aussi plus de complexité dans votre application. En effet, vous devrez changer vos requêtes à la base de données. Votre application reposera sur plus de table, vous aurez donc à joindre les tables dans vos requêtes, ce qui résultera en une perte de performance dans vos applications.
Je conseillerai aux développeurs un passage obligé par la normalisation en début de projet,et d’arrêter la normalisation de leurs tables juste avant que la structure de ces tables devienne trop compliquée. Dans notre exemple, extraire une ligne de la table labels résulte en la création de la requête suivante :
SELECT * FROM labels as A INNER JOIN zip as B ON B.zip_ID=A.zip_ID INNER JOIN states as C ON C.state_ID=B.state_ID WHERE A.label_ID=’1′ LIMIT 1;

Webliographie :

Tutoriel sur la normalisation par Olivier Dahan

Normalisation Mysql (English)

Recherche Fulltext sous MySql

Scripter un moteur de recherche nécessite :

  • un formulaire côté client pour soumettre des requêtes
  • des champs de table de base de données à l’intérieur desquels la recherche doit s’effectuer
  • des requêtes à la base de données pour rechercher la chaîne postée par le client

Je veux tout d’abord me pencher sur les caractéristiques de la base de données pour effectuer une telle recherche.

Auaparavant, j’utilisais des requêtes avec des sous-requêtes du type :

SELECT id,title,content from table_name WHERE title LIKE ‘% ».$search. »%’ OR content LIKE ‘% ».$search. »%’;

qui effectue une recherche de style expression régulière et peut causer des problèmes de ressources MySql (grand nombre de lignes parcourues, grand nombre de résultats,…).

Sous MySql, une recherche FULLTEXT peut solutionner ce problème de ressources et produire des résultats probants puisqu’elle effectue une recherche sur des données indexées, et donc pas directement dans la table. Ce type de recherche permet l’utilisation :

  • d’une liste de mots rejetés (mots que le serveurs exclut par défaut de la recherche)
  • de recherches booléennes (utilisant + ou -, par exemple, pour ajouter ou enlever des mots de la recherche)
  • d’un score de pertinence

Type de table qui permet l’indexation Fulltext

La recherche FULLTEXT est disponible avec les tables utilisant MyISAM comme moteur de stockage. Bien que le moteur de stockage InnoDB offre l’énorme avantage de pouvoir utiliser des transactions (gestion des erreurs par commit et rollback), la recherche par indexation Fulltext y est absente. Concentrons-nous donc sur les tables MyISAM.

Vous pouvez définir un index Fulltext sur un ou plusieurs champs de type CHAR, VARCHAR et TEXT. Comme mentionné dans la référence MySql reference sur le sujet, créer des données dans une table disposant d’un index Fulltext prendra plus de temps. Ainsi, si un nombre conséquent de données doit être traité avec un index Fulltext (et c’est dans ce cas qu’il sera le plus efficace), il vaut mieux d’abord insérer les données dans la table, puis créer l’index.

Vous pouvez créer un index sur les 2 champs « title » et « content » avec la requête suivante :

ALTER TABLE table_name ADD FULLTEXT index_name (‘title’ , ‘content’);

Une fois l’index Fulltext de la table défini, faites une recherche comme suit :

SELECT id,title,content from table_name WHERE MATCH(title,content) AGAINST (‘ ».$search. »‘);

Les champs de la sous-requête MATCH doivent être les mêmes que ceux définis dans l’index fulltext de la table, et vous pouvez créer un index Fulltext sur un champ ou plus.

Paramétrage de la recherche Fulltext

MySql est configuré avec un lot de paramètres par défaut :

  • les résultats sont classés par score de pertinence que MySql donne à chaque donnée trouvée
  • les mots de moins de 4 caractères seront ignorés
  • l’index Fulltext contient uniquement des mots entiers
  • liste des mots exclus d’une recherche Fulltext. Ce paramètre dépend de la langue d’installation de MySql
  • le score de chaque donnée trouvée dépendra du nombre d’occurences de ce mot dans la table. Si un mot apparaît dans plus de la moitié des lignes de la table, il sera ignoré

Le changement de ces paramètres par défaut ne sera possible que dans le cas où votre serveur Web MySql vous permet de les modifier.

Recherche en mode booléen

La sous-requête MATCH… AGAINST… permet la recherche booléenne :

SELECT id,title,content from table_name WHERE MATCH(title,content) AGAINST (‘ ».$search. »‘ IN BOOLEAN MODE);

MySql retournera toutes les lignes correspondantes même si plus de 50% des lignes contiennent le mot-clef.

Les recherches booléennes permettent en outre l’utilisation d’opérateurs comme + ou – pour forcer MySql à retourner les lignes contenant ‘works’ et cacher les lignes contenant ‘tables’ :

SELECT id,title,content from table_name WHERE MATCH(title,content) AGAINST (‘+works -tables’ IN BOOLEAN MODE);

Vous pouvez aussi utiliser l’opérateur * comme joker en mode booléen pour rechercher une partie de mot :

SELECT id,title,content from table_name WHERE MATCH(title,content) AGAINST (‘peopl*’ IN BOOLEAN MODE);

Webliography :

Référence sur la recherche FULLTEXT sous MySql

Référence sur la recherche FULLTEXT en mode Booléen sous MySql

PHP5 Afficher toutes les requêtes MySql d’une page Web

Le développeur qui veut rationaliser et/ou améliorer ses requêtes MySql peut trouver utile de faire afficher toutes les requêtes qu’une page Web a généré ainsi que le temps que le serveur a dédié à la production de cette page. Ceci n’est utile qu’en phase de développement. Une fois cette phase terminée, il faudra commenter (// ou /* */) ces quelques lignes de script pour gagner du temps de travail CPU.

Changements dans la classe MySql

Pour compter les requêtes MySql générées par une page Web et en afficher la liste, le développeur devrait ajouter une variable statique à sa classe MySql :

public static $queries = array();

Lors de l’initialisation de la classe, la variable $queries deviendra un tableau vide (array). A chaque fois qu’une requête est envoyée à la méthode d’exécution de la classe, cette requête sera ajoutée au tableau de la manière suivante :
array_push(self::$queries,$query);
Avant de détruire l’objet $mysql :
return count(self::$queries);
retournera le nombre de requêtes MySql générées par une page Web.
return self::$queries;
retournera le tableau contenant toutes les requêtes MySql de la page courante.

PHP script execution time

Pour vérifier combien de temps un script prend du début à la fin, utilisez microtime :
<?php
//haut du script PHP
$start_time = microtime(true); // >= PHP 5.0.0 donne ainsi le microtime avec décimales
//bas du script PHP
$end_time = microtime(true);
$total_time = $end_time – $start_time;
?>

Mysql5 – Requêtes multiples

Si vous voulez parcourir toutes les améliorations de MySql5, lisez les official relase notes.

L’objectif de ce post est d’écrire des requêtes MySql plus efficaces. Certains serveurs surveillent les ressources MySql qu’occupent une page Web. Si le nombre de requêtes pour une simple page Web est considéré comme trop gourmand en ressources, le développeur pourrait bien recevoir un avertissement (voire plus) de la part de l’hébergeur.

Lisez l’article « PHP5 : Afficher toutes les requêtes MySql d’une page Web » pour surveiller vos requêtes.

Ce sur quoi je veux me concentrer ici est une syntaxe qui a été introduite dans MySql 4.1 mais qui me semble trop peu utilisée :

INSERT INTO… ON DUPLICATE KEY UPDATE…

Mais parcourons tout d’abord la requête multiple pour l’effacement de données.

Effacer plusieurs lignes en une seule requête (DELETE)

Au lieu de générer des requêtes dans le but d’effacer des lignes d’une table :

$mysql = Mysql(); //initialisation de l’objet

$mysql->Connect(); //connexion à la BD

$array = array(1,2,4); //lignes à effacer

FOREACH($array as $value) {

$sql = « DELETE FROM table_name WHERE id=’$value’ »;

$mysql->strictExecute($sql); //Exécution de la requête par l’objet $mysql

}

ce qui produira 3 requêtes dans cet exemple, vous pourriez faire la chose suivante :

$mysql = Mysql(); //initialisation de l’objet

$mysql->Connect(); //connexion à la BD

$array = array(1,2,4); //lignes à effacer

$sql = «  »;

FOREACH($array as $value) {

IF($sql <> «  ») $sql .=  » OR « ;

$sql .= « id=’$value’ »; //ajoute la chaîne id=’$value’ à $sql

}

$sql = « DELETE FROM table_name WHERE « .$sql; //construit la requête unique: DELETE FROM table_name WHERE id=’1′ OR id=’2′ OR id=’4′;

$mysql->strictExecute($sql); //Exécution de la requête par l’objet $mysql

ce qui produira une seule requête à la BD.

Je conseillerais même d’utiliser la sous-requête IN suivie de la condition :

$mysql = Mysql(); //initialisation de l’objet

$mysql->Connect(); //connexion à la DB

$array = array(1,2,4); //lignes à effacer

$sql = «  »;

FOREACH($array as $value) {

IF($sql <> «  ») $sql .= « , « ;

$sql .= « ‘$value’ »; //ajoute la chaîne id=’$value’ à $sql

}

$sql = « DELETE FROM table_name WHERE id IN (« .$sql. ») »; //construit la requête unique : DELETE FROM table_name WHERE id IN (’1′, ’2′, ’4′);

$mysql->strictExecute($sql); //Exécution de la requête par l’objet $mysql

Insérer plusieurs lignes en une seule requête (INSERT TO)

Pour insérer de multiples lignes en une seule requête, utilisez la requête suivante :

$mysql = Mysql(); //initialisation de l’objet

$mysql->Connect(); //connexion à la BD

$books = array(0=>array(« title »=> »Mysql explained », »n_pages »=> »350″),

1=>array(« title »=> »PHP explained », »n_pages »=> »150″)

); //lignes à insérer

$sql = «  »;

FOREACH($books as $value) {

IF($sql <> «  ») $sql .= « , « ;

$sql .= « (‘ ».$value["title"]. »‘,’ ».$value["n_pages"]. »‘) »;

}

$sql = « INSERT INTO table_name(title,n_pages) VALUES ».$sql;

$mysql->strictExecute($sql); //Exécution de la requête par l’objet $mysql

Mettre à jour plusieurs lignes (INSERT INTO… ON DUPLICATE KEY UPDATE)

Mettre à jour des lignes dans une table MySql peut se faire de la manière suivante :

$mysql = Mysql(); //initialisation de l’objet

$mysql->Connect(); //connexion à la BD

$books = array(0=>array(« id »=>1, »title »=> »Mysql explained », »n_pages »=> »450″),

1=>array(« id »=>2, »title »=> »PHP explained », »n_pages »=> »450″)

); //lignes à mettre à jour

$sql = «  »;

FOREACH($books as $value) {

$sql .= « UPDATE table_name SET title=’ ».$value["title"]. »‘,n_pages=’ ».$value["n_pages"]. »‘ WHERE id=’ ».$value["id"]. »‘ »;

$mysql->strictExecute($sql); //Exécution de la requête par l’objet $mysql

}

ce qui produira 2 requêtes.

Il est possible de n’en générer qu’une seule pour mettre à jour les 2 lignes par une requête INSERT INTO avec la syntaxe ON DUPLICATE KEY UPDATE. Dans le cas où la clef existe déjà (ici la valeur id = 1 et id = 2), MySql opérera un update. Si la clef n’existe pas, MySql fera un insert into classique :

$mysql = Mysql(); //initialisation de l’objet

$mysql->Connect(); //connexion à la BD

$books = array(0=>array(« id »=>1, »title »=> »Mysql explained », »n_pages »=> »450″),

1=>array(« id »=>2, »title »=> »PHP explained », »n_pages »=> »450″)

); //lignes à modifier

$sql = «  »;

FOREACH($books as $value) {

IF($sql <> «  ») $sql .= « , »;

$sql .= (‘ ».$value["id"]. »‘,’ ».$value["title"]. »‘,’ ».$value["n_pages"]. »‘);

}

$sql = « INSERT INTO table_name(id,title,n_pages) VALUES ».$sql. » ON DUPLICATE KEY UPDATEid=VALUES(id),title=VALUES(title),n_pages=VALUES(n_pages) »;

$mysql->strictExecute($sql); //Exécution de la requête par l’objet $mysql

Cette requête est tellement efficace qu’elle permet non seulement la mise à jour de plusieurs lignes, mais qu’elle inclut aussi l’insertion de nouvelles données, et ce, en une seule et même requête.

Webliographie :

MySql5 Release notes

PhpMyadmin sans login

PhpMyadmin est un logiciel libre rédigé en PHP pour la gestion des bases de données Mysql.

Pour des raisons de développement sur une machine locale uniquement, le développeur peut désirer se connecter directement à ses bases de données sans passer par la page login. Pour des raisons évidentes de sécurité, ne choisissez pas cette configuration sur un serveur Web ou toute autre machine accessible via un réseau local, par exemple.

Pour supprimer l’authentification par mot de passe, il faut modifier le fichier /config.inc.php :

/* Authentication type */
$cfg['Servers'][$i]['auth_type'] = ‘config’; //valeur par défaut : ‘cookie’
/* Server parameters */
$cfg['Servers'][$i]['host'] = ‘localhost’;
$cfg['Servers'][$i]['user'] = ‘root’; //modifiez la valeur par l’utilisateur MySql autorisé
$cfg['Servers'][$i]['password'] =  »; //modifiez la valeur par le mot de passe de l’utilisateur

testé sur PhpMyadmin 3.2.4

Webliography :

PhpMyadmin.net