Carnet Wiki

Sqlite export pour SPIP

SPIP-Contrib :: Carnet Wiki :: Recherche :

Sqlite export pour SPIP

A ce jour, la meilleure méthode pour passer de SQLite à MySQL est expliquée ici : Passage de SQLite à MySQL (et réciproque). Si vous ne pouvez l’appliquer , vous pouvez peut-être obtenir un résultat avec celle-ci mais...

Ce plugin est expérimental ! Même s’il semble donner un résultat satisfaisant, les différences entre sqlite3 et mysql ne sont pas toutes prises en compte. Au jour de la rédaction de ces lignes, je n’ai pas de retour de problèmes majeurs mais les tests ont été peu nombreux et ce problème majeur c’est peut-être chez vous qu’il se produira. Aujourd’hui ou plus tard. Vous êtes prévenu-e-s !

Le plugin tente de réaliser un dump MySQL de votre site en Sqlite3. Si l’opération fonctionne, le dump obtenu est à importer dans une base MySQL, via phpmyadmin ou Adminer (Voir aussi Editer votre base « en ligne » avec Adminer), par exemple.

Prologue

J’ai découvert en aout 2012 que certains plugins n’étaient pas fonctionnels en sqlite3, ou que certaines fonctions étaient absentes dans ce moteur de base de données. Du coup, pour un site dont je m’occupe et qui avait été installé avec une base sqlite3 (choix par défaut en SPIP3 mais MySQL est aussi possible), j’ai voulu repasser sur un base MySQL et là... Pas de solution facile.

Passer son SPIP de Sqlite à MySQL - ce qui ne marche pas

J’ai testé plusieurs possibilités :

  1. Le dump au format sqlite proposé au titre de sauvegarde par SPIP3 ne permet pas de changer de moteur de base de données. Par contre, si votre hébergement supporte sqlite3, les sauvegardes sont fonctionnelles en vue d’une restauration sur le même site, avec le même moteur de base de données.
  2. le passage par des exports intermédiaires (type csv) sont possibles mais ils ne concernent que les données. C’est à vous de faire en sorte que les bases contiennent les mêmes tables, de vérifier quelles tables sont nécessaires, de gérer les histoires de charset, etc. Compliqué mais surtout fastidieux. Tant qu’à procéder de la sorte, autant suivre la procédure « Passage de SQLite à MySQL (et réciproque) ».
  3. phpmyadmin ne gère pas sqlite, mais adminer le fait. Cependant, un export sql d’une base slite3 n’est pas utilisable en import dans une base mysql. Pour voir où ça bloque, j’ai simplement comparé un dump mysql et un dump sqlite (ce sont de simples fichiers texte)... Les différences ne sont pas énormes mais elles sont visibles et bloquantes.

A l’arrivée, comme je savais ne pas être seul dans le cas, je me suis lancé dans une tentative de faire quelque chose de réutilisable... Cela a donné un squelette spécifique, distribué via ce plugin.

Ma démarche

Le passage par les 3 étapes ci-dessus m’a permis de réaliser que :

-  il y a lieu de différencier la question des données (les contenus) de la question de la structure de la base (le contenant)
-  les contenus sqlite passent quasi tels que en mysql : le seul problème que j’ai détecté dans ma base est lié aux guillemets droits simples. Ils sont tantôt enregistrés en entités numériques, tantôt échappés, tantôt présents seuls...
-  les déclarations de tables sont différentes mais pas tellement. Les différences principales se trouvent dans les déclarations de clés (primaires ou non), dans la déclaration de certains types de données, dans certaines syntaxes (PRAGMA)...

Du coup, il m’est venu l’idée de réaliser sur un squelette qui récupèrerait les données de la base sqlite et de les encadrer avec les déclarations de tables qui conviendraient pour MySQL. Autrement dit, composer avec SPIP un fichier texte compatible avec MySQL, semblable à ceux qu’on peut produire avec les fonctions d’exportation de phpmyadmin ou adminer.

Comme j’aime jouer avec les itérateurs de SPIP (la fameuse boucle DATA) et que par ailleurs, j’ai appris que la structure d’une base Sqlite est décrite dans une table spécifique (sqlite_master), cela m’a semblé faisable et j’ai essayé de le faire... Je détaillerai plus bas le code de ce squelette.

La qualité et les limites du plugin

Si j’écris cette page c’est que ce plugin a désormais été utile à plusieurs personnes, outre moi-même. Comme il est basé sur le fonctionnement interne de Sqlite (et non sur la configuration du site ou des plugin), il présente l’intérêt de récupérer l’intégralité de la base de données, indépendamment du fait que les tables soient réellement utilisées dans la configuration du site au moment du dump. Cela peut-être très utile si vous utilisez des tables externes ou s’il vous arrive, comme moi, de désactivez plus ou moins temporairement certains plugins...

Cependant, l’utilisation du plugin n’est pas forcément vouée à la réussite sur votre site...

La principale limite est celle qui jusqu’ici n’a pas posé de problème... Elle est évoquée en haut de cette page. MySQL et Sqlite sont deux moteurs différents, utilisant des procédures, des stockages et des types de données différents. Ce plugin n’a absolument pas visé à l’exhaustivité à ce sujet. Les différences qu’il permet de corriger sont celles qui me sont apparues visuellement par la comparaison de fichiers dump produits avec ces deux moteurs. Il y en a certainement d’autres qui ont jour apparaitront et seront probablement bloquantes.

Ensuite, il y a des limites liées à votre hébergement et à la taille de votre base de données. En résumé, disons que les configurations de PHP et de Sqlite/MySQL prévoient des limites de temps d’exécution des scripts, de taille de fichiers utilisables et d’utilisation de la RAM du serveur. Au plus ces limites sont basses et au plus votre base de donnée est importante, au moins il y a de chances que le dump MySQL soit produit.

Par contre, et c’est important, comme une base de donnée Sqlite tient en un seul fichier, il est facile de récupérer celui-ci sur votre machine personnelle. Il vous suffit alors d’installer localement un serveur et d’en pousser les limites à des valeurs suffisantes pour que le dump soit produit. C’est une opération que j’ai réalisée plusieurs fois. Néanmoins, l’importation du dump dans le serveur MySQL de votre hébergeur risque d’être un peu plus compliquée vu que le dump pour MySQL sera d’une taille analogue à celle du dump Sqlite. Une solution est alors de découper le dump MySQL en plusieurs fichiers et de les importer l’un après l’autre.

Les ressources

Vous trouverez toutes les infos sur l’implémentation du langage SQL dans Sqlite à la page https://www.sqlite.org/lang.html.

Le squelette (inclure/sqlite-mysql.html) est appelé via une inclusion simple (depuis dumpmysql.html), ce qui permet de limiter son usage au webmestre du site : c’est tout le contenu d’une base de données qui est potentiellement exposé au monde ! Il utilise aussi des fltres qui sont définis dans dumpmysql_fonctions.php, selon le principe de SPIP qui permet de définir des fonctions dédiées à un squelette xxx.html dans un fichier xxx_fonctions.php

A noter enfin que lorsque vous faites un développement avec les itérateurs, vous avez intérêt à avoir sous la main le code [<pre>(#VALEUR|print_r{1})</pre>] qui vous permet de visualiser le contenu brut des tableaux procurés par les itérateurs. Je l’ai utilisé pour chaque boucle DATA, puis retiré uniquement quand le résultat a été satisfaisant.

Le plugin est sur la zone (http://zone.spip.org/trac/spip-zone...) et vous pouvez en obtenir un zip via Trac : http://zone.spip.org/trac/spip-zone.... Vu son côté expérimental, je ne pense pas qu’il soit opportun de le rendre disponible via SVP. Les personnes prêtes à prendre le risque trouveront bien le chemin jusqu’ici.

Une fois le plugin installé et activé sur un site en Sqlite, le webmestre peut lancer la création du fihcier dump en appelant la page spip.php?page=dumpmysql (le lien est fourni dans la description du plugin - configuration du site, page de gestion des plugins).

Le squelette

Le fichier principal est inclure/sqlite-mysql.html. La version présente dans le plugin vise à ce que le dump produit soit « lisible » mais c’est au prix d’un code très compact. Voici ce même code mis en forme de manière plus aérée (mais qui produirait en l’état un dump beaucoup moins lisible du fait des sauts de lignes intempestifs qu’il produirait). Le code est commenté plus ou moins sommairement dans des balises #REM. Le code des filtres présents dans dumpmysql_fonctions.php est repris plus bas.

  1. #CACHE{0}
  2.  
  3. [(#REM) lister les tables et description sqlite]
  4. [(#REM) array type=>table name=>nom table tbl_name=>nom_table rootpage=>2 sql=>CREATE TABLE name (...,PRIMARY KEY(key))]
  5.  
  6. <BOUCLE_tables(DATA){source sql,SELECT * FROM sqlite_master WHERE type='table'}>
  7. #SET{table,#VALEUR*{name}}
  8. #SET{cle_primaire,#VALEUR*{sql}|cle_prim}
  9. #SET{req_table,PRAGMA table_info ( #VALEUR*{name} )}
  10.  
  11. [(#REM) les enonces de base: supprimer et creer ]
  12.  
  13. DROP TABLE IF EXISTS `#VALEUR*{name}`; CREATE TABLE `#VALEUR*{name}`
  14.  
  15. ([(#REM) liste des champs - RECUPERER AUTO INCREMENT !!! - on stocke aussi pour les insert]
  16.  
  17. #SET{champs,#ARRAY}
  18.  
  19. <B_table_desc>
  20. <BOUCLE_table_desc(DATA){source sql,#GET{req_table}}{", "}>
  21. `#VALEUR*{name}` [ (#VALEUR*{type}|=={"TIMESTAMP"}|?{"timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP",#VALEUR*{type}|strtolower}) ][ (#VALEUR*{notnull}|=={1}|?{"NOT NULL",""}) ][(#VALEUR*{type}|=={"INTEGER"}|et{#VALEUR*{name}|=={#GET{cle_primaire}}}|oui) AUTO_INCREMENT ][ default (#VALEUR*{dflt_value}|=={"''"}|?{"",#VALEUR*{dflt_value}})]
  22.  
  23. [(#REM) et on stocke la liste des champs pour plus tard]
  24. #SET{champs,#GET{champs}|push{#VALEUR*{name}}}
  25. </BOUCLE_table_desc>
  26.  
  27. [(#REM) ensuite la clé primaire ]
  28. [, PRIMARY KEY ((#GET{cle_primaire}))]
  29.  
  30. [(#REM) on cherche la liste des autres clés]
  31. #SET{req_keys,PRAGMA index_list( #GET{table} )}
  32.  
  33. <B_keys_liste> ,
  34. <BOUCLE_keys_liste(DATA){source sql,#GET{req_keys}}{","}>
  35.  
  36. [(#REM) le nom de table est répété dans les clés, on va l'enlever]
  37. #SET{key,#VALEUR*{name}|keyname{#GET{table}}}[ KEY `(#GET{key})` ]
  38.  
  39. [(#REM) les valeurs des autres clés ]
  40. #SET{req_cle,PRAGMA index_info( #VALEUR*{name})}
  41.  
  42. <B_keys> (
  43. <BOUCLE_keys(DATA){source sql,#GET{req_cle}}{", "}>
  44. `#VALEUR*{name}`
  45. </BOUCLE_keys>
  46. )</B_keys>
  47.  
  48. </BOUCLE_keys_liste>
  49.  
  50. ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
  51.  
  52. [(#REM) insérons-maintenant les valeurs des contenus]
  53. #SET{req_donnees,SELECT * FROM #GET{table}}
  54.  
  55. <B_lignes>INSERT INTO `#GET{table}` (
  56. <BOUCLE_champs(DATA){source tableau,#GET{champs}}{", "}>
  57. `#VALEUR*`
  58. </BOUCLE_champs>)
  59. VALUES
  60. <BOUCLE_lignes(DATA){source sql,#GET{req_donnees}}{", "}>
  61. <B_donnees>(
  62. <BOUCLE_donnees(DATA){source table,#VALEUR*}{", "}>
  63. [(#VALEUR*|?{['(#VALEUR*|mysql_prep)'],"''"})]
  64. </BOUCLE_donnees>
  65. )</B_donnees>
  66.  
  67. </BOUCLE_lignes>
  68. ;</B_lignes>
  69.  
  70. </BOUCLE_tables>
  71.  
  72. INSERT INTO `spip_meta` (`nom`, `valeur`, `impt`, `maj`) VALUES ('charset_collation_sql_base', 'utf8_general_ci', 'non', ''),('charset_sql_base', 'utf8', 'non', ''),('charset_sql_connexion', 'utf8', 'non', '');

Télécharger

Et le code des filtres :

  1. <?php
  2. // la cle primaire est declaree avec le reste du sql => recuperer sa seule declaration
  3. function cle_prim($val) {
  4. if ($position_cle=strpos($val,"PRIMARY")) {
  5. $cle_primaire=substr($val,$position_cle);
  6. $cle_primaire=str_replace("))",")",$cle_primaire);
  7. if (preg_match(",PRIMARY KEY \(([^\)]+)\),Uims", $cle_primaire, $reg)) {
  8. # echo "<br>".$reg[1];
  9. return $reg[1];
  10. }
  11. }
  12. return $cle_primaire;
  13. }
  14.  
  15. //sqlite fournit des noms de cle de la forme nom_table_cle => supprimer nom_table
  16. function keyname($nomlong,$nomtable) {
  17. $nomtable=$nomtable."_";
  18. if ($nomlong!=="") {
  19. $nom_cle=str_replace($nomtable,"",$nomlong);
  20. return $nom_cle;
  21. }
  22. else return false;
  23. }
  24.  
  25. // nettoyer les guillemets droits simples pour MySQL => enlever les entites num, les échappements préexistants + addslashes
  26. function mysql_prep($value) {
  27. $value = str_replace("&#39;","'",$value);
  28. $value = str_replace("\'","'",$value);
  29. $text_mysql = addslashes($value);
  30. return $text_mysql;
  31. }
  32.  
  33. ?>

Télécharger

La suite plus tard peut-être (surtout s’il y a des demandes ;-) ).

Des améliorations ?

Si ce système devait s’avérer crédible, c’est chacune des limites qu’il faudrait adresser au cours de développements ultérieurs. Cela n’est pas forcément dans mes compétences actuelles (mais j’apprend chaque jour davantage). N’empêche, si leur coeur vous en dit, on crée des branches et faisons ça ensemble ;-)

C’est un wiki : n’hésitez pas à compléter et corriger... Eventuellement, envoyez un mail sur spip-zone, histoire que l’on puisse envisager des améliorations.