Dans une publication datant du 11 septembre, Ari Stathopoulos, développeur WordPress, et qui se présente également comme un évangéliste du développement durable, plaide pour un support officiel de SQLite dans WordPress. Dans un appel à l'action, Stathopoulos écrit : « Faisons-en sorte que WordPress supporte officiellement SQLite ». Plus tôt, cette semaine, il introduit un module permettant de tester l'implémentation de SQLite dans WordPress.Il s'agit d'un travail continu en cours, mais il fonctionnerait suffisamment bien pour être inclus en tant que module expérimental. « Les problèmes ne concernent pas tant l'implémentation de SQLite elle-même que l'activation/désactivation du module et l'expérience globale de l'utilisateur au cours de ce processus », écrit Stathopoulos.
À la base, WordPress est le moyen le plus simple et le plus populaire de créer votre propre site Web ou blog. En fait, WordPress alimente plus de 43,3 % de tous les sites Web sur Internet. Oui, plus d'un site Web sur quatre que vous visitez est probablement alimenté par WordPress. D'un point de vue un peu plus technique, WordPress est un système de gestion de contenu open source sous licence GPLv2, ce qui signifie que tout le monde peut utiliser ou modifier le logiciel WordPress gratuitement. Un système de gestion de contenu est essentiellement un outil qui permet de gérer facilement les aspects importants de votre site Web, comme le contenu, sans avoir besoin de s'y connaître en programmation.
Le résultat final est que WordPress rend la création d'un site web accessible à tous, même aux personnes qui ne sont pas des développeurs. Le succès de WordPress s'explique en partie par le fait qu'il est extensible, accrochable et qu'il peut être utilisé et modifié pour accomplir presque toutes les tâches sur le Web. Cependant, un aspect de WordPress n'a jamais changé, malgré l'augmentation des cas d'utilisation et de la popularité de WordPress : la base de données.
« WordPress nécessite l'installation de MySQL/MariaDB sur un site. MySQL n'est sans doute optimal que pour certains scénarios : les sites de taille moyenne. Les grands sites mettent généralement en œuvre des piles de bases de données personnalisées en fonction de leurs besoins spécifiques, ce qui dépasse le cadre de cette proposition », écrit Stathopoulos.
SQLite est un moteur de base de données relationnelle léger accessible par le langage SQL.
Contrairement aux serveurs de bases de données traditionnels, comme MySQL ou PostgreSQL, sa particularité est de ne pas reproduire le schéma habituel client-serveur, mais d'être directement intégrée aux programmes. Selon l'équipe de développement de SQLite, le SGBD est probablement l'un des cinq modules logiciels les plus déployés, toutes descriptions confondues. Étant donné que SQLite est largement utilisé dans tous les smartphones et qu'il y a plus de 4,0 milliards de smartphones en service, chacun contenant des centaines de fichiers de base de données SQLite, il est probable qu'il y ait plus d'un trillion de bases de données SQLite en service. Cette présentation de SQLite est-elle suffisante pour plaider en faveur d’un support officiel de SQLite dans WordPress ?
Idéalement, WordPress permettrait de choisir le type de base de données lors de l'installation. Cela pourrait être fait à l'aide d'un guide d'installation, ou d'une simple constante dans wp-config.php. Pour ce faire, WordPress devrait disposer d'une couche d'abstraction de base de données. Il ne s'agit pas d'une idée innovante ou radicale dans l'espace des systèmes de gestion de contenu (content management system ou CMS en anglais); Drupal dispose d'une couche d'abstraction de base de données solide depuis plus d'une décennie. Laravel, Symfony et d'autres incluent également des ORM (Object-Relational Mapping ) qui permettent d'utiliser plusieurs types de bases de données.
Construire une couche d'abstraction de base de données pour WordPress serait une tâche colossale bien que selon Stathopoulos, ce serait une tâche que, à un moment donné dans le futur, nous devrons peut-être entreprendre pour assurer l'évolution continue et la longévité du projet. En guise de solution intermédiaire, Stathopoulos propose de mettre en œuvre une solution pour les sites et blogs de petite et moyenne taille. « Ces sites n'ont pas nécessairement besoin d'une base de données MySQL à part entière », estime-t-il. Pour lui, SQLite semble être la solution idéale :
- c'est la base de données la plus utilisée dans le monde (déjà dit) ;
- elle est multiplateforme et peut fonctionner sur n'importe quel appareil ;
- Elle est incluse par défaut dans toutes les installations PHP (sauf si elle est explicitement désactivée).
SQLite s'efforce d'être flexible en ce qui concerne les types de données du contenu qu'il stocke. Par exemple, si une colonne de la table a pour type INTEGER, SQLite essaie de convertir tout ce qui est inséré dans cette colonne en un nombre entier. Ainsi, une tentative d'insertion de la chaîne 123 se traduit par l'insertion d'un nombre entier 123. Mais si le contenu ne peut pas être converti sans perte en un nombre entier, par exemple si l'entrée est 'xyz', alors la chaîne originale est insérée à la place.
SQLite est probablement plus utilisé que tous les autres moteurs de base de données réunis. Des milliards et des milliards de copies de SQLite existent dans la nature. SQLite est présent dans :
- tous les navigateurs web Firefox, Chrome et Safari ;
- la plupart des téléviseurs et des décodeurs câble ;
- la plupart des systèmes multimédias automobiles ;
- d'innombrables millions d'autres applications ;
- toutes les instances de Skype ;
- chaque instance d'iTunes ;
- chaque appareil Android ;
- tous les clients Dropbox ;
- PHP et Python ;
- chaque Mac.
Certains développeurs apprécient la liberté qu'offrent les règles de typage flexibles de SQLite et utilisent cette liberté à leur avantage.
De l’avis de Stathopoulos, la configuration minimale requise pour WordPress serait un simple serveur PHP, sans besoin d'un serveur de base de données distinct. La prise en charge de SQLite permettrait de réduire les coûts d'hébergement, de diminuer la consommation d'énergie et de réduire les coûts de performance sur les serveurs bas de gamme.
Implémentation de SQLite dans WordPress Core
L'utilisation de SQLite dans WordPress est, à ce stade, simple ; il existe des implémentations qui existent et évoluent depuis plus de 8 ans. Elles ont été testées de manière approfondie et il a été prouvé qu'elles fonctionnent de manière transparente. Ces implémentations sont des fichiers wp-content/db.php que les utilisateurs peuvent ajouter à leur installation ; elles ne sont pas difficiles à utiliser. Cependant, la plupart des gens ne les connaissent pas. Ils ne savent pas qu'ils ont la possibilité d'acheter un hébergement moins cher sans-mysql et d'installer WordPress en utilisant une base de données SQLite.
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 | /**
* Plugin Name: WP SQLite DB
* Description: SQLite database driver drop-in. (based on SQLite Integration by Kojima Toshiyasu)
* Author: Evan Mattson
* This project is based on the original work of Kojima Toshiyasu and his SQLite Integration plugin.
*/
namespace WP_SQLite_DB {
use DateTime;
use DateInterval;
use PDO;
use PDOException;
use SQLite3;
if (! defined('ABSPATH')) {
exit;
}
/**
* USE_MYSQL is a directive for using MySQL for database.
* If you want to change the database from SQLite to MySQL or from MySQL to SQLite,
* the line below in the wp-config.php will enable you to use MySQL.
*
*
* define('USE_MYSQL', true);
*
*
* If you want to use SQLite, the line below will do. Or simply removing the line will
* be enough.
*
*
* define('USE_MYSQL', false);
*
*/
if (defined('USE_MYSQL') && USE_MYSQL) {
return;
}
function pdo_log_error($message, $data = null)
{
if (strpos($_SERVER['SCRIPT_NAME'], 'wp-admin') !== false) {
$admin_dir = '';
} else {
$admin_dir = 'wp-admin/';
}
die(<<"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
$message
$data
HTML
);
}
if (version_compare(PHP_VERSION, '5.4', '<')) {
pdo_log_error('PHP version on this server is too old.', sprintf("Your server is running PHP version %d but this SQLite driver requires at least 5.4", phpversion()));
}
if (! extension_loaded('pdo')) {
pdo_log_error('PHP PDO Extension is not loaded.',
'Your PHP installation appears to be missing the PDO extension which is required for this version of WordPress.');
}
if (! extension_loaded('pdo_sqlite')) {
pdo_log_error('PDO Driver for SQLite is missing.',
'Your PHP installation appears not to have the right PDO drivers loaded. These are required for this version of WordPress and the type of database you have specified.');
}
/**
* Notice:
* Your scripts have the permission to create directories or files on your server.
* If you write in your wp-config.php like below, we take these definitions.
* define('DB_DIR', '/full_path_to_the_database_directory/');
* define('DB_FILE', 'database_file_name');
*/
/**
* FQDBDIR is a directory where the sqlite database file is placed.
* If DB_DIR is defined, it is used as FQDBDIR.
*/
if (defined('DB_DIR')) {
if (substr(DB_DIR, -1, 1) != '/') {
define('FQDBDIR', DB_DIR . '/');
} else {
define('FQDBDIR', DB_DIR);
}
} else {
if (defined('WP_CONTENT_DIR')) {
define('FQDBDIR', WP_CONTENT_DIR . '/database/');
} else {
define('FQDBDIR', ABSPATH . 'wp-content/database/');
}
}
/**
* FQDB is a database file name. If DB_FILE is defined, it is used
* as FQDB.
*/
if (defined('DB_FILE')) {
define('FQDB', FQDBDIR . DB_FILE);
} else {
define('FQDB', FQDBDIR . '.ht.sqlite');
}
/**
* This class defines user defined functions(UDFs) for PDO library.
*
* These functions replace those used in the SQL statement with the PHP functions.
*
* Usage:
*
*
* new PDOSQLiteUDFS(ref_to_pdo_obj);
*
*
* This automatically enables ref_to_pdo_obj to replace the function in the SQL statement
* to the ones defined here.
*/
class PDOSQLiteUDFS
{
/**
* The class constructor
*
* Initializes the use defined functions to PDO object with PDO::sqliteCreateFunction().
*
* @param PDO $pdo
*/
public function __construct($pdo)
{
if (! $pdo) {
wp_die('Database is not initialized.', 'Database Error');
}
foreach ($this->functions as $f => $t) {
$pdo->sqliteCreateFunction($f, [$this, $t]);
}
} |
« Ils ne devraient pas non plus avoir à le savoir... Après tout, ils veulent juste un simple site d'entreprise ou un blog. » WordPress pourrait officiellement supporter SQLite en incluant l'une des implémentations SQLite existantes dans Core. Nous devrions nous assurer qu'elle est correctement testée et prise en charge, et en outre, sensibiliser et exposer l'option aux utilisateurs.
SQLite dans Core ou dans un plugin
Le Développeur WordPress, évangéliste du développement durable, Ari Stathopoulos, étale les raisons pour lesquelles il pense que SQLite devrait être dans WordPress Core plutôt que dans un plugin. Selon lui, choisir un type de base de données est quelque chose qui devrait se produire lors de la première installation d'un site. Ce n'est pas quelque chose qui devrait être fait après, car cela nécessiterait de migrer les données d'une base de données à une autre, ce qui peut souvent être complexe.
WordPress inclut l'implémentation de MySQL dans le noyau, alors l’implémentation de SQLite devrait doit cohabiter avec elle. La migration des données peut (et devrait) se faire dans un plugin pour faciliter les migrations pour les sites existants s'ils le souhaitent, mais le moteur de base de données lui-même devrait appartnir au noyau.
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 | /**
* Method to change the MySQL field types to SQLite compatible types.
*
* If column name is the same as the key value, e.g. "date" or "timestamp",
* and the column is on the top of the line, we add a single quote and avoid
* to be replaced. But this doesn't work if that column name is in the middle
* of the line.
* Order of the key value is important. Don't change it.
*
* @access private
*/
private function rewrite_field_types()
{
$array_types = [
'bit' => 'integer',
'bool' => 'integer',
'boolean' => 'integer',
'tinyint' => 'integer',
'smallint' => 'integer',
'mediumint' => 'integer',
'int' => 'integer',
'integer' => 'integer',
'bigint' => 'integer',
'float' => 'real',
'double' => 'real',
'decimal' => 'real',
'dec' => 'real',
'numeric' => 'real',
'fixed' => 'real',
'date' => 'text',
'datetime' => 'text',
'timestamp' => 'text',
'time' => 'text',
'year' => 'text',
'char' => 'text',
'varchar' => 'text',
'binary' => 'integer',
'varbinary' => 'blob',
'tinyblob' => 'blob',
'tinytext' => 'text',
'blob' => 'blob',
'text' => 'text',
'mediumblob' => 'blob',
'mediumtext' => 'text',
'longblob' => 'blob',
'longtext' => 'text',
];
foreach ($array_types as $o => $r) {
if (preg_match("/^\\s*(?<!')$o\\s+(.+$)/im", $this->_query, $match)) {
$ptrn = "/$match[1]/im";
$replaced = str_ireplace($ptrn, '#placeholder#', $this->_query);
$replaced = str_ireplace($o, "'{$o}'", $replaced);
$this->_query = str_replace('#placeholder#', $ptrn, $replaced);
}
$pattern = "/\\b(?<!')$o\\b\\s*(\([^\)]*\)*)?\\s*/ims";
if (preg_match("/^\\s*.*?\\s*\(.*?$o.*?\)/im", $this->_query)) {
;
} else {
$this->_query = preg_replace($pattern, " $r ", $this->_query);
}
}
}
/**
* Method for stripping the comments from the SQL statement.
*
* @access private
*/
private function rewrite_comments()
{
$this->_query = preg_replace("/# --------------------------------------------------------/",
"-- ******************************************************", $this->_query);
$this->_query = preg_replace("/#/", "--", $this->_query);
} |
- des performances accrues sur les serveurs et les environnements bas de gamme ;
- un potentiel de croissance de WordPress sur des marchés où il n’a pas accès en raison des exigences du système ;
- potentiel de croissance sur le marché de l'hébergement en utilisant des « scénarios » d'installation ;
- réduction de la consommation d'énergie - durabilité accrue pour le projet WordPress ;
- Poursuite de la mission de WordPress visant à "démocratiser l'édition" pour tous ;
- Plus facile de contribuer à WordPress - télécharger les fichiers et exécuter le serveur PHP intégré sans autre configuration requise.
Source : Github
Et vous ?
Êtes-vous pour ou contre un support officiel de SQLite pour WordPress ? Partagez-vous, l'avis d'Ari Stathopoulos, pour une intégration dans le noyau et non dans un plugin ? Quel est votre avis sur le sujet ?Voir aussi :
SQLite 3.40 est disponible, le moteur de base de données léger apporte le support officiel de Wasm, une API de récupération qui pourrait récupérer une partie du contenu d'un fichier de BD corrompu Il y'aurait plus de mille milliards de bases de données SQLite en utilisation active, faisant du SGBD le composant logiciel le plus largement déployé et utilisé 
