Rien de sorcier, juste un peu de logique.

Premièrement on crée la nouvelle table (table_clonee) à partir de la table_source :

CREATE TABLE table_clonee LIKE table_source ;

Puis nous insérons les données dans la nouvelle table en « lisant » celles de la table_source

INSERT INTO table_clonee SELECT * FROM table_source ;

Simple et efficace.

Note : cela doit fonctionner également sur d’autres moteurs de bases de données, moyennant quelques adaptations syntaxiques

Article original écrit par Mr Xhark publié sur Blogmotion le 08/06/2010 | 6 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

Etant donné que les radars automatiques utilisent la reconnaissance de caractère (OCR) pour identifier les véhicules de façon automatisée, cette injection SQL inhibe l’enregistrement de la plaque. L’injection détruit au passage la base de données, empêchant le radar de fonctionner après le passage de cette voiture (même sur les plaques non trafiquées).

Vous vous doutez bien qu’il serait trop facile de détourner de cette façon les contrôles de vitesse, mais fallait-il encore avoir l’idée. Quoi que se balader avec une requête SQL sur le pare-choc est loin d’être sans risque face aux contrôles humains

Via Clubic, Source Gizmodo

Article original écrit par Mr Xhark publié sur Blogmotion le 23/03/2010 | 16 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

De nombreuses entreprises utilisent aujourd’hui Microsoft Access pour gérer leurs « base de données », souvent internes. Personnellement je trouve que Microsft Access n’est pas un réel SGBD tant il est limité. On doit son succès grâce à l’interface graphique qui permet de tout réaliser ou presque sans connaître une seule commande SQL.

Si vous êtes développeur, votre entreprise peut vous demander de développer une application de gestion basée sur Access. Pourquoi ? Tout simplement car la personne qui devra accéder à cette base n’aura aucune compétence en SQL et que Access reste simple à utiliser graphiquement.

Ne jetez pas l’éponge tout de suite, voici une solution redoutablement efficace ! Je vous propose de développer votre application sur une base MySQL avec par exemple un code source PHP (ou Perl, python, ), en rendant accessible  le tout avec Access et/ou Excel !

Les versions utilisées pour mon exemple sont : Office 2007 et MySQL 5.x (fonctionne également avec Office 2003, seuls les menus changent).

Base de données démo

Pour notre exemple, je vous propose de créer une base de donnée simple :

CREATE TABLE `blogmotion`.`demo` (
`id` INT NOT NULL AUTO_INCREMENT ,
`prenom` VARCHAR( 30 ) NOT NULL ,
`nom` VARCHAR( 50 ) NOT NULL ,
PRIMARY KEY ( `id` )
) ENGINE = MYISAM ;

Puis insérons quelques données :

INSERT INTO `demo` (`id`, `prenom`, `nom`) VALUES
(1, 'Jean', 'Némar'),
(2, 'Jay', 'Lafrite'),
(3, 'Paul', 'Hochon'),
(4, 'Michael', 'Hurni');

Vous pouvez injecter directement le code dans PhpMyAdmin si vous l’utilisez via l’onglet SQL.

Installation du connecteur ODBC

Note : Cette manipulation doit-être réalisée sur tous les postes qui devront accéder à cette base de donnée via Access.

Pour permettre l’accès à la base MySQL de façon transparente au travers d’une application Microsoft nous devons installer un connecteur ODBC.

1. MySQL propose justement de télécharger ce connecteur MySQL ODBC gratuitement. Installez-le.
2. Se rendre dans le menu Démarrer > Outils d’administration > Source de données (ODBC), ou via démarrer > exécuter : odbcad32.exe
3. Cliquer sur Ajouter
   
4. Choisir MySQL ODBC :
   
   Puis cliquer sur Terminer.
5. Préciser un nom et une description pour ce connecteur (de votre choix) puis entrez le nom ou adresse IP du serveur MySQL (localhost pour moi) ainsi que l’utilisateur ayant accès à votre base de données :
   
   Vous devrez obtenir Connection Successful si vous cliquez sur le bouton Test.
   Si ce n’est pas le cas, pensez à vérifier que votre serveur MySQL fonctionne et que celui-ci est accessible à partir de l’extérieur, l’accès est parfois restreint sur l’interface de boucle local (localhost) 127.0.0.1.
6. Cliquer sur OK, vous devriez obtenir ceci :
   
7. C’est terminé pour la partie ODBC.

Accès à MySQL depuis Access

Access permet, via le connecteur ODBC, d’utiliser les données MySQL de deux façons différentes :

1. de façon synchrone : chaque modification effectuée avec Access est répercutée sur la base MySQL (similaire à une vue)
2. de façon indépendante : toutes les données de la ou les tables sont copiées dans Access sans aucun lien avec MySQL

Si c’est uniquement pour de la lecture, optez pour la méthode 2. Dans le cas contraire (mise à jour, suppression, ajout d’informations) optez pour la méthode 1.

Lancer Access, puis dans une nouvelle base :

1. Dans l’onglet Données externes > Plus : Base de données ODBC :
   
2. Dans le deuxième onglet Source de données machine sélectionner le Connecteur précédemment créé :
   
3. Pour établir une liaison synchrone, sélectionner Lier à la source de données en créant une table attachée :
   
4. Sélectionner que vous souhaitez exploiter et cliquer sur OK :
   
5. Vous retrouvez vos données de MySQL dans Access :
   

Attention : chaque modification effectuée sera répercutée sur votre base MySQL.

Accès à MySQL depuis Excel

L’interfaçage entre Microsoft Excel et MySQL se fait via Microsoft Query, utilitaire inclut dans la suite Office.

L’opération varie quelque peu par rapport à Access :

1. Via l’onglet Données > Données > A partir d’autre sources : Provenance : Microsoft Query
   
2. Puis sélectionner la ou les tables souhaitées :
   
   Cliquer sur le bouton Aperçu maintenant pour vérifier l’accès, puis sur Suivant :
   
3. Si vous souhaitez filtrer les données sélectionnez les colonnes, sinon cliquer sur Suivant :
   
4. Vous pouvez faire un tri sur une colonne, sinon cliquer sur Suivant :
   
5. Cliquer sur le bouton Terminer :
   
6. Sélectionnez la méthode d’affichage des données dans votre classeur souhaitée, puis sur le bouton OK :
   
7. Et voici le résultat :
   

Si vous modifiez une valeur dans la base MySQL, vous pouvez forcer la mise à jour de la feuille Excel en faisant un clic droit sur la cellule concernée > Actualiser. Ou presser simultanément CTRL+ALT+F5 pour mettre à jour toutes les cellules.

Vous retrouverez les informations de connexion via l’onglet Données > Connexion du ruban Office.

Conclusion

Le connecteur MySQL permet de préserver votre base de données MySQL dans le moteur MySQL tout en la rendant accessible aux applications Microsoft Office.

C’est simple, propre et efficace ! Il ne reste plus qu’à mêler les macros pour les plus téméraires…

Article original écrit par Mr Xhark publié sur Blogmotion le 05/02/2010 | 15 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

L’efficacité et la stabilité de MySQL ne sont plus à démontrer tant au niveau personnel que dans le monde professionnel. Soutenons MySQL !

Historique

Comme vous le savez, MySQL AB a été acheté le 16 janvier 2008 par Sun Microsystems pour un milliard de dollars. Puis en 2009, Sun Microsystems a été acquis par Oracle Corporation qui a donc récupéré les deux produits concurrents que sont Oracle et MySQL.

Afin de sauver MySQL, le créateur de la base de données éponyme, Michael Widenius, a lancé une campagne mondiale d’information et une pétition en ligne pour s’opposer au rachat de MySQL par Oracle (tous les dés ne sont pas encore jetés).

Une campagne mondiale

Le site de la campagne mondiale est disponible en 20 langues sur HelpMysql.org dont le français et rencontre d’ores et déjà un succès massif auprès des utilisateurs de MySQL. Un soutien déjà 50 fois supérieur à celui que Oracle annonçait il y a trois semaines.

On dénombre plus de 24000 signatures qui ont été présentées aux régulateurs de la commission européenne, au ministère chinois du commerce (MOFCOM), au service fédéral russe de lutte contre les monopoles (FAS) et auprès de la commission suisse. Plus de 5000 signatures proviennent de développeurs indépendants et plus de 3000 concernent des utilisateurs en entreprise (http://www.helpmysql.org/en/stats)

Les organisateurs de la campagne indiquent que les livraisons suivantes de nouvelles signatures auront maintenant lieu une à deux fois par semaine. La pétition sera prochainement élargie pour être transmise aux autorités de la concurrence d’autres pays, en particulier Japon et Brésil.

Michael Wiedenius a senti le vent tourner assez tôt puiqu’il a crée MariaDB dès le rachat de MySQL, un SGBD 100% compatible avec MySQL et diffusé sous licence GPL.

Personnellement je pense que pour garantir la pérennisation de MySQL, le projet Open Source devrait demeurer indépendant d’Oracle, et c’est également l’avis de son créateur :

« chaque entreprise était par conséquent libre de choisir sa base de données et l’alternative permettait de négocier avec les revendeurs d’Oracle en utilisant l’argument MySQL. Eliminer le problème MySQL rapportera facilement un milliard de dollars par an à Oracle, voire plus » (source)

N’abandonnons pas MySQL

Je pense que je n’aurai pas à convaincre les développeurs et administrateurs systèmes de participer à cette pétition. En revanche, même si vous êtes un simple internaute qui apprécie surfer librement et gratuitement, sachez que ce type de rachat risque de ne pas faire évoluer le web dans le bon sens. MySQL permet à la plus grande majorité de sites web de fonctionner et ses dérivés sont nombreux. Ce n’est pas sa licence GPL qui empêchera MySQL de disparaître.

Pour soutenir MySQL vous pouvez :

1. Signer la pétition (english version)
2. Afficher les logos de soutien sur votre blog / site
3. Suire le compte twitter @helpmysql

Je n’ai pas pour habitude de faire parti des plus grincheux et de signer des pétitions à tout va, mais là je me sens fortement concerné et je n’ai pas hésité une seule seconde. Sans MySQL, vous ne seriez probablement pas en train de lire ce billet, et Blogmotion n’existerait pas, tout comme WordPress, et des millions de sites et applications…

Je compte sur vous fidèles lecteurs !

Via le communiqué de presse officiel

Article original écrit par Mr Xhark publié sur Blogmotion le 10/01/2010 | 6 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

Typiquement, lorsque vous changez de nom de domaine et que vous disposez d’un blog cette opération est très pratique mais surtout, nécessaire. Comme je me sers régulièrement de cette petite astuce, j’ai décidé de la partager, bien qu’elle ne soit absolument pas secrète ou complexe.

Commande MySQL :

UPDATE Table SET le_champ=REPLACE(le_champ,'chaine a remplacer','chaine de remplacement) WHERE le_champ LIKE '%chaine a remplacer%'

Voici un exemple d’utilisation, tiré d’une de l’opération de migration de Blogmotion (changement de serveur). Cette modification impactait le chemin absolu du blog sur un serveur Linux :

UPDATE wp_postmeta SET meta_value = replace(meta_value, '/var/www/virtual/blogmotion.fr/htdocs', '/var/www/sites/blogmotion.fr/html') WHERE meta_value LIKE '%/var/www/virtual/blogmotion.fr/htdocs%'

Disons que c’est l’équivalent du str_replace si vous utilisez PHP.

Si vous obtenez des erreurs d’exécution, apportez la plus grande attention à la syntaxe.

N’hésitez pas à partager vos astuces dans les commentaires.

Article original écrit par Mr Xhark publié sur Blogmotion le 31/10/2009 | 2 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

Ce guide concerne uniquement le changement d’adresse du serveur MySQL, un futur billet traitera du déplacement des données.

Ce guide concerne la plateforme WordPress, avec une base de données MySQL, le tout migrant depuis un serveur Linux Debian (dédié) vers un autre serveur du même type.

1 : Exporter la base de données

Si vous êtes sur un serveur mutualisé, vous devez exporter votre base avec un outil fourni par votre hébergeur, tel que PhpMyAdmin, mais vous devrez sûrement segmenter l’export à cause de la limitation de l’import par la suite (2 Mo par defaut).

Sur un serveur dédié, il vous suffit de lancer l’export de votre base de données via une connexion SSH (en root) :

mysqldump [base de données] -u [utilisateur sql] -p > /chemin/vers/export.sql

Ce qui peut par exemple être :

mysqldump blogbase -u bloguser -p > ./export.sql

2 : Envoyer l’export

Il nous faut maintenant envoyer l’export vers le nouveau serveur. Vous pouvez pour cela le faire via FTP, SFTP, HTTP, etc.

Mais la solution la plus adaptée dans ce genre de situation reste le transfert via la commande rsync.

Toujours en root :

rsync -e ssh /chemin/versexport.sql utilisateur@ip_nouveauserveur:/chemin/destination

L’ip peut également être le nom de domaine, ou encore le reverseip

Par exemple :

rsync -e ssh /export.sql 90.0.0.1:/root/

Je n’ai pas précisé l’utilisateur car étant en root sur le premier serveur, la connexion s’effctura en root sur le second. Le serveur va de toute façon demander le mot de passe associé, qu’il vous faudra entrer.

3 : Import de la base de données

Il nous reste à importer toutes les données de la base contenues dans le fichier d’export sql sur notre nouveau serveur. J’avais par ailleurs déjà abordé ce thème lors d’un précédent billet.

Etablir une connexion SSH en tant que super utilisateur (root) :

[ssh]mysql [base de données] -u [utilisateur sql] -p < /chemin/vers/export.sql[/shell]

Ce qui donne chez moi :

[ssh]mysql blogbase -u bloguser -p < /root/export.sql[/shell]

Fichiers de configuration

Pensez également à modifier (si nécessaire) certaines valeurs dans le fichier /wp-config.php :

• l’adresse du serveur MySQL (si c’est « localhost » vous êtes tranquille)
• le nom de la base de données
• le nom de l’utilisateur MySQL
• le mot de passe de l’utilisateur MySQL

Conclusion

Essayer de réaliser ces opérations dans un minimum de temps si vous ne coupez pas l’accès au blog. En effet, si vous recevez un nouveau commentaire après l’export, celui-ci passera à la trappe.

Pour pallier à ceci, vous pouvez restreindre l’accès au blog à l’aide d’un .htaccess (lire « précautions et informations ») limitant l’accès à votre seule adresse IP le temps de la migration.

L’idéal étant de préparer le nouveau serveur (création de la base, de l’utilisateur MySQL, etc.) avant de couper l’accès au blog.

Grâce à cette technique, personne ne s’est rendu compte du changement de serveur pour Blogmotion, pourtant réalisé en soirée, heure importante en terme de visites, mais sans coupure

Article original écrit par Mr Xhark publié sur Blogmotion le 11/06/2009 | 5 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

Une base de donnée bien pensée dès le départ n’est pas censée contenir de doublons, mais comme l’erreur est humaine, je vous propose une méthode de suppression de vos doublons MySQL.

Création de la table

Pour l’exemple je vous propose de créer une table ‘membre’ simple :

CREATE TABLE membre (
id int(10) NOT NULL AUTO_INCREMENT,
nom varchar(30),
prenom varchar(30),
age int(3),
datecreation timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY (id)
);

Nous admettrons que l’unicité est basée sur la composition du nom et prénom, c’est à dire que deux personnes physiquement différentes ne peuvent avoir le même couple de nom+prénom (ce qui dans la réalité n’est bien sûr pas valable).

Insertion de champs avec un doublon

Insérons 4 champs, les deux premiers étant identiques (doublons) :

INSERT INTO membre (nom,prenom,age) values ('durand','marc',34);
INSERT INTO membre (nom,prenom,age) values ('durand','marc',34);
INSERT INTO membre (nom,prenom,age) values ('hurni','michael',22);
INSERT INTO membre (nom,prenom,age) values ('morin','luc',52);

Vérifions que les champs soient bien présents dans la base :

SELECT * FROM membre;
+----+--------+---------+------+---------------------+
| id | nom    | prenom  | age  | datecreation        |
+----+--------+---------+------+---------------------+
|  1 | durand | marc    |   34 | 2008-11-21 20:16:57 |
|  2 | durand | marc    |   34 | 2008-11-21 20:16:57 |
|  3 | hurni  | michael |   22 | 2008-11-21 20:16:57 |
|  4 | morin  | luc     |   52 | 2008-11-21 20:16:57 |
+----+--------+---------+------+---------------------+

Nous observons que Marc Durand est bien en double dans la base de données, il y a donc un doublon (en admettant qu’il n’y ait qu’un seul Marc Durand sur terre).

Création d’un index d’unicité

Cet index va permettre de supprimer les enregistrements comportant certains champs identiques, nom et prénom pour mon cas :

ALTER IGNORE TABLE membre ADD UNIQUE INDEX(nom,prenom);
Query OK, 4 rows affected (0.46 sec)
Records: 4  Duplicates: 1  Warnings: 0

MySQL nous indique qu’un doublon a été supprimé (duplicate).

Interrogation de la table

Vérifions que le deuxième ‘Marc Durand’ n’est plus dans la table :

select * from membre;
+----+--------+---------+------+---------------------+
| id | nom    | prenom  | age  | datecreation        |
+----+--------+---------+------+---------------------+
|  1 | durand | marc    |   34 | 2008-11-21 20:16:57 |
|  3 | hurni  | michael |   22 | 2008-11-21 20:16:57 |
|  4 | morin  | luc     |   52 | 2008-11-21 20:16:57 |
+----+--------+---------+------+---------------------+
3 rows in set (0.00 sec)

L’enregistrement ayant pour identifiant ’2′ a bien été supprimé.

Suppression de l’index

Si vous ne souhaitez pas préserver cet d’unicité, bien qu’il interdise les doublons à l’insertion, vous pouvez le supprimer :

ALTER TABLE membre DROP INDEX nom;
Query OK, 3 rows affected (0.38 sec)
Records: 3  Duplicates: 0  Warnings: 0

Vérification de la structure en ligne de commande :

desc membre;
+--------------+-------------+------+-----+-------------------+----------------+
| Field        | Type        | Null | Key | Default           | Extra          |
+--------------+-------------+------+-----+-------------------+----------------+
| id           | int(10)     | NO   | PRI | NULL              | auto_increment |
| nom          | varchar(30) | YES  | MUL | NULL              |                |
| prenom       | varchar(30) | YES  |     | NULL              |                |
| age          | int(3)      | YES  |     | NULL              |                |
| datecreation | timestamp   | NO   |     | CURRENT_TIMESTAMP |                |
+--------------+-------------+------+-----+-------------------+----------------+
5 rows in set (0.07 sec)

Conclusion

Il existe plusieurs techniques de suppression des doublons MySQL, les plus mauvaises étant celles préconisant l’usage d’un langage tiers (php, bash, etc.) basées sur un parcours en boucle de la table car trop consommatrices en ressources. Sachez qu’il est bien plus rentable d’utiliser les fonctions natives du moteur SQL, quitte à faire fonctionner un tant soit peu ses méninges et consulter la documentation MySQL (ou autre moteur SQL suivant celui utilisé ). Cette solution étant rapide et fiable, j’espère que vous en aurez l’utilité.

Article original écrit par Mr Xhark publié sur Blogmotion le 22/11/2008 | 12 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

Bien évidemment lorsque vous avez un hébergement il y a une base de donnée MySQL. Prenons l’exemple de l’hébergeur Free qui le propose. Vous pouvez vous connecter uniquement à votre base de donnée depuis votre espace personnel Free, les connexions MySQL depuis l’extérieur ne sont pas autorisées : comme dans bien des cas !

Vous pouvez avoir besoin d’une base de donnée commune accessible depuis plusieurs noms de domaines mutualisés (Free ou autre) lors d’un projet commun par exemple. Vous pouvez aussi en avoir marre de la politique de Free à savoir : les bases de données ne doivent pas être utilisées à des fins de stockage (logs, statistiques…).

Le site « Databases for free«   propose  une base de donnée gratuite et sans aucune restriction d’accès ! De plus, depuis le 31 Mars 2008 vous avez le choix d’accéder à votre base de données avec MySQL 5 ou MySQL 6. Pour faciliter la gestion de vos données c’est PhpMyAdmin qui est utilisé comme interface.

Vous pouvez tout à fait accéder à votre base de donnée depuis un script PHP sur votre espace perso Free

Accéder à DB4Free
Blog de DB4Free

Article original écrit par Mr Xhark publié sur Blogmotion le 10/05/2008 | 2 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons

J’écris ce petit billet tout simplement car je vois souvent des scripts PHP traiter les dates dans des formats exotiques. Vous avez besoin de récupérer une date et une heure (ou l’un des deux) stockée dans votre base de données en PHP et vous ne savez pas comment faire ? Cette astuce est pour vous

Premièrement : utilisez le format DATETIME de SQL. Pas de INT, VARCHAR ou autre type inapproprié ! De plus utiliser ce format permet d’avoir un script universel et indépendant des langues locales configurées sur le serveur.

Deuxièmement votre date et heure seront d’autant plus facile à récupérer en PHP puisqu’ils sont stockés dans un seul et unique champ :

SELECT DATE_FORMAT(nom_du_champ, 'le %d/%m/%Y à %k:%H:%s')
AS date_heure
FROM table where [condition]

Exemple de résultat retourné : le 24/04/2008 à 9:09:07

Il vous suffit d’appliquer un explode si vous souhaitez séparer la date et l’heure, ou alors (et c’est plus simple) de faire deux sélections SQL.
Récupération de la date et de l’heure de manière séparée :

SELECT DATE_FORMAT(nom_du_champ, '%d/%m/%Y') AS ma_date,
DATE_FORMAT(nom_du_champ, '%k:%H:%s') AS mon_heure
FROM table where [condition]

En espérant que suite à ce billet vous userez correctement des différents types de champs MySQL mis à votre disposition

L’usage du timestamp(); PHP n’est pas conseillé car limité : le TimeStamp UNIX commence au 1er janvier 1970 et sera valable jusqu’en 2038 (pour l’instant sur des machines en 32bits : 2^31 = 2147483647). Si vous devez traiter des dates antérieures au 01/01/1970 : le format DATE ou DATETIME deviennent alors beaucoup plus pratique

Pour vos conversions timestamp vous pouvez utiliser cette extension firefox ou bien ce convertisseur en ligne très pratique

Article original écrit par Mr Xhark publié sur Blogmotion le 28/04/2008 | 8 commentaires |
Attention : l'intégralité de ce billet est protégée par la licence Creative Commons