/**
* Creer une table,
* ou ajouter les champs manquants si elle existe deja
*
* http://doc.spip.org/@creer_ou_upgrader_table
*
* @param string $table
* @param array $desc
* @param bool|string $autoinc
* 'auto' pour detecter automatiquement si le champ doit etre autoinc ou non
* en fonction de la table
* @param bool $upgrade
* @param string $serveur
* @return void
*/
function creer_ou_upgrader_table($table, $desc, $autoinc, $upgrade = false, $serveur = '')
{
$sql_desc = $upgrade ? sql_showtable($table, true, $serveur) : false;
if (!$sql_desc) {
if ($autoinc === 'auto') {
$autoinc = base_determine_autoinc($table, $desc);
}
sql_create($table, $desc['field'], $desc['key'], $autoinc, false, $serveur);
} else {
// ajouter les champs manquants
// on ne supprime jamais les champs, car c'est dangereux
// c'est toujours a faire manuellement
$last = '';
foreach ($desc['field'] as $field => $type) {
if (!isset($sql_desc['field'][$field])) {
sql_alter("TABLE {$table} ADD {$field} {$type}" . ($last ? " AFTER {$last}" : ""), $serveur);
}
$last = $field;
}
foreach ($desc['key'] as $key => $type) {
// Ne pas oublier les cas des cles non nommees dans la declaration et qui sont retournees
// par le showtable sous la forme d'un index de tableau "KEY $type" et non "KEY"
if (!isset($sql_desc['key'][$key]) and !isset($sql_desc['key']["{$key} {$type}"])) {
sql_alter("TABLE {$table} ADD {$key} ({$type})", $serveur);
}
$last = $field;
}
}
}
function dump_afficher_tables_restaurees_erreurs($status_file)
{
$status = dump_lire_status($status_file);
$tables = $status['tables_copiees'];
$corps = "";
$erreurs = array();
if (!$tables) {
return "<p>" . _T("dump:erreur_aucune_donnee_restauree") . "</p>";
}
// lister les tables copiees aller verifier dans la base
// qu'on a le bon nombre de donnees
foreach ($tables as $t => $n) {
if (!sql_showtable($t, true) or $n === 0) {
$erreurs[$t] = _T('dump:erreur_table_absente', array('table' => "<strong>{$t}</strong>"));
} else {
$n = abs(intval($n));
$n_dump = intval(sql_countsel($t));
if ($n_dump < $n) {
$erreurs[$t] = _T('dump:erreur_table_donnees_manquantes', array('table' => "<strong>{$t}</strong>"));
}
}
}
if (count($erreurs)) {
$corps = "<ul class='spip'><li>" . implode("</li><li class='spip'>", $erreurs) . "</li></ul>";
}
return $corps;
}
function maj_11778()
{
// si presence id_type
$s = sql_showtable('spip_types_documents');
if (isset($s['field']['id_type'])) {
sql_alter('TABLE spip_types_documents CHANGE id_type id_type BIGINT(21) NOT NULL');
sql_alter('TABLE spip_types_documents DROP id_type');
sql_alter('TABLE spip_types_documents ADD PRIMARY KEY (extension)');
}
}
/**
* Fonction d'installation, mise a jour de la base
*
* @param unknown_type $nom_meta_base_version
* @param unknown_type $version_cible
*/
function accesrestreint_upgrade($nom_meta_base_version,$version_cible){
$current_version = 0.0;
if ( (!isset($GLOBALS['meta'][$nom_meta_base_version]) )
|| (($current_version = $GLOBALS['meta'][$nom_meta_base_version])!=$version_cible)){
include_spip('base/acces_restreint');
if (version_compare($current_version,'0.0','<=')){
include_spip('base/create');
include_spip('base/abstract_sql');
creer_base();
// ajout des champs publique/privee si pas existants
$desc = sql_showtable("spip_zones", true);
if (!isset($desc['field']['publique']))
sql_alter("TABLE spip_zones ADD publique ENUM('non', 'oui') DEFAULT 'oui' NOT NULL AFTER descriptif");
if (!isset($desc['field']['privee']))
sql_alter("TABLE spip_zones ADD privee ENUM('non', 'oui') DEFAULT 'non' NOT NULL AFTER publique");
echo "AccesRestreint Install<br/>";
effacer_meta($nom_meta_base_version); // salade de majuscules
ecrire_meta($nom_meta_base_version,$current_version=$version_cible,'non');
}
if (version_compare($current_version,'0.2','<')){
include_spip('base/create');
include_spip('base/abstract_sql');
// ajout des champs publique/privee si pas existants
$desc = sql_showtable("spip_zones", true);
if (!isset($desc['field']['publique']))
sql_alter("TABLE spip_zones ADD publique ENUM('non', 'oui') DEFAULT 'oui' NOT NULL AFTER descriptif");
if (!isset($desc['field']['privee']))
sql_alter("TABLE spip_zones ADD privee ENUM('non', 'oui') DEFAULT 'non' NOT NULL AFTER publique");
echo "AccesRestreint@0.2<br />";
ecrire_meta($nom_meta_base_version,$current_version='0.2','non');
}
if (version_compare($current_version,'0.3','<')){
sql_alter("TABLE `zones_auteurs` DROP INDEX `id_zone`");
sql_alter("TABLE `zones_auteurs` ADD PRIMARY KEY ( `id_zone` , `id_auteur` )");
sql_alter("TABLE `zones_rubriques` DROP INDEX `id_zone`");
sql_alter("TABLE `zones_rubriques` ADD PRIMARY KEY ( `id_zone` , `id_rubrique` )");
echo "AccesRestreint@0.3<br />";
ecrire_meta($nom_meta_base_version,$current_version='0.3','non');
}
if (version_compare($current_version,'0.3.0.1','<')){
#ecrire_meta('creer_htaccess','oui');
echo "AccesRestreint@0.3.0.1<br />";
ecrire_meta($nom_meta_base_version,$current_version='0.3.0.1','non');
}
if (version_compare($current_version,'0.3.0.2','<')){
#ecrire_meta('creer_htaccess','oui');
sql_alter("TABLE spip_zone ALTER titre SET DEFAULT ''");
sql_alter("TABLE spip_zone ALTER descriptif SET DEFAULT ''");
echo "AccesRestreint@0.3.0.2<br />";
ecrire_meta($nom_meta_base_version,$current_version='0.3.0.2','non');
}
}
}
/**
* Créer une table,
* ou ajouter les champs manquants si elle existe déjà
*
* @param string $table
* @param array $desc
* @param bool|string $autoinc
* 'auto' pour detecter automatiquement si le champ doit etre autoinc ou non
* en fonction de la table
* @param bool $upgrade
* @param string $serveur
* @return void
*/
function creer_ou_upgrader_table($table, $desc, $autoinc, $upgrade = false, $serveur = '')
{
#spip_log("creer_ou_upgrader_table table=$table autoinc=$autoinc upgrade=$upgrade","dbinstall"._LOG_INFO_IMPORTANTE);
$sql_desc = $upgrade ? sql_showtable($table, true, $serveur) : false;
#if (!$sql_desc) $sql_desc = false;
#spip_log("table=$table sql_desc:$sql_desc","dbinstall"._LOG_INFO_IMPORTANTE);
if (!$sql_desc) {
if ($autoinc === 'auto') {
$autoinc = base_determine_autoinc($table, $desc);
}
#spip_log("sql_create $table autoinc=$autoinc","dbinstall"._LOG_INFO_IMPORTANTE);
sql_create($table, $desc['field'], $desc['key'], $autoinc, false, $serveur);
// verifier la bonne installation de la table (php-fpm es-tu la ?)
$sql_desc = sql_showtable($table, true, $serveur);
#if (!$sql_desc) $sql_desc = false;
#spip_log("Resultat table=$table sql_desc:$sql_desc","dbinstall"._LOG_INFO_IMPORTANTE);
if (!$sql_desc) {
// on retente avec un sleep ?
sleep(1);
sql_create($table, $desc['field'], $desc['key'], $autoinc, false, $serveur);
$sql_desc = sql_showtable($table, true, $serveur);
#if (!$sql_desc) $sql_desc = false;
#spip_log("Resultat table=$table sql_desc:$sql_desc","dbinstall"._LOG_INFO_IMPORTANTE);
if (!$sql_desc) {
spip_log("Echec creation table {$table}", "maj" . _LOG_CRITIQUE);
}
}
} else {
#spip_log("sql_alter $table ... (on s'en fiche)","dbinstall"._LOG_INFO_IMPORTANTE);
// ajouter les champs manquants
// on ne supprime jamais les champs, car c'est dangereux
// c'est toujours a faire manuellement
$last = '';
foreach ($desc['field'] as $field => $type) {
if (!isset($sql_desc['field'][$field])) {
sql_alter("TABLE {$table} ADD {$field} {$type}" . ($last ? " AFTER {$last}" : ""), $serveur);
}
$last = $field;
}
foreach ($desc['key'] as $key => $type) {
// Ne pas oublier les cas des cles non nommees dans la declaration et qui sont retournees
// par le showtable sous la forme d'un index de tableau "KEY $type" et non "KEY"
if (!isset($sql_desc['key'][$key]) and !isset($sql_desc['key']["{$key} {$type}"])) {
sql_alter("TABLE {$table} ADD {$key} ({$type})", $serveur);
}
$last = $field;
}
}
}
function creer_ou_upgrader_table($table,$desc,$autoinc,$upgrade=false,$serveur='') {
$sql_desc = $upgrade ? sql_showtable($table,true,$serveur) : false;
if (!$sql_desc)
sql_create($table, $desc['field'], $desc['key'], $autoinc, false, $serveur);
else {
// ajouter les champs manquants
$last = '';
foreach($desc['field'] as $field=>$type){
if (!isset($sql_desc['field'][$field]))
sql_alter("TABLE $table ADD $field $type".($last?" AFTER $last":""),$serveur);
$last = $field;
}
foreach($desc['key'] as $key=>$type){
if (!isset($sql_desc['key'][$key]))
sql_alter("TABLE $table ADD $key ($type)",$serveur);
$last = $field;
}
}
}
function spip_connect($serveur = '', $version = '')
{
global $connexions, $spip_sql_version;
$serveur = !is_string($serveur) ? '' : strtolower($serveur);
$index = $serveur ? $serveur : 0;
if (!$version) {
$version = $spip_sql_version;
}
if (isset($connexions[$index][$version])) {
return $connexions[$index];
}
include_spip('base/abstract_sql');
$install = _request('exec') == 'install';
// Premiere connexion ?
if (!($old = isset($connexions[$index]))) {
$f = !preg_match('/^[\\w\\.]*$/', $serveur) ? '' : ($serveur ? _DIR_CONNECT . $serveur . '.php' : (_FILE_CONNECT ? _FILE_CONNECT : ($install ? _FILE_CONNECT_TMP : '')));
// installation pas faite
unset($GLOBALS['db_ok']);
unset($GLOBALS['spip_connect_version']);
if ($f) {
if (is_readable($f)) {
include $f;
} elseif ($serveur and !$install) {
// chercher une declaration de serveur dans le path
// qui pourra un jour servir a declarer des bases sqlite
// par des plugins. Et sert aussi aux boucles POUR.
find_in_path("{$serveur}.php", 'connect/', true);
}
}
if (!isset($GLOBALS['db_ok'])) {
// fera mieux la prochaine fois
if ($install) {
return false;
}
if ($f and is_readable($f)) {
spip_log("spip_connect: fichier de connexion '{$f}' OK.", _LOG_INFO_IMPORTANTE);
} else {
spip_log("spip_connect: fichier de connexion '{$f}' non trouve", _LOG_INFO_IMPORTANTE);
}
spip_log("spip_connect: echec connexion ou serveur {$index} mal defini dans '{$f}'.", _LOG_HS);
// ne plus reessayer si ce n'est pas l'install
return $connexions[$index] = false;
}
$connexions[$index] = $GLOBALS['db_ok'];
}
// si la connexion a deja ete tentee mais a echoue, le dire!
if (!$connexions[$index]) {
return false;
}
// la connexion a reussi ou etait deja faite.
// chargement de la version du jeu de fonctions
// si pas dans le fichier par defaut
$type = $GLOBALS['db_ok']['type'];
$jeu = 'spip_' . $type . '_functions_' . $version;
if (!isset($GLOBALS[$jeu])) {
if (!find_in_path($type . '_' . $version . '.php', 'req/', true)) {
spip_log("spip_connect: serveur {$index} version '{$version}' non defini pour '{$type}'", _LOG_HS);
// ne plus reessayer
return $connexions[$index][$version] = array();
}
}
$connexions[$index][$version] = $GLOBALS[$jeu];
if ($old) {
return $connexions[$index];
}
$connexions[$index]['spip_connect_version'] = isset($GLOBALS['spip_connect_version']) ? $GLOBALS['spip_connect_version'] : 0;
// initialisation de l'alphabet utilise dans les connexions SQL
// si l'installation l'a determine.
// Celui du serveur principal l'impose aux serveurs secondaires
// s'ils le connaissent
if (!$serveur) {
$charset = spip_connect_main($GLOBALS[$jeu]);
if (!$charset) {
unset($connexions[$index]);
spip_log("spip_connect: absence de charset", _LOG_AVERTISSEMENT);
return false;
}
} else {
// spip_meta n'existe pas toujours dans la base
// C'est le cas d'un dump sqlite par exemple
if ($connexions[$index]['spip_connect_version'] and sql_showtable('spip_meta', true, $serveur) and $r = sql_getfetsel('valeur', 'spip_meta', "nom='charset_sql_connexion'", '', '', '', '', $serveur)) {
$charset = $r;
} else {
$charset = -1;
}
}
if ($charset != -1) {
$f = $GLOBALS[$jeu]['set_charset'];
if (function_exists($f)) {
$f($charset, $serveur);
}
}
return $connexions[$index];
}
function install_etape_3b_dist()
{
$login = _request('login');
$email = _request('email');
$nom = _request('nom');
$pass = _request('pass');
$pass_verif = _request('pass_verif');
$server_db = defined('_INSTALL_SERVER_DB') ? _INSTALL_SERVER_DB : _request('server_db');
if (!defined('_PASS_LONGUEUR_MINI')) {
define('_PASS_LONGUEUR_MINI', 6);
}
if (!defined('_LOGIN_TROP_COURT')) {
define('_LOGIN_TROP_COURT', 4);
}
if ($login) {
$echec = $pass != $pass_verif ? _T('info_passes_identiques') : (strlen($pass) < _PASS_LONGUEUR_MINI ? _T('info_passe_trop_court_car_pluriel', array('nb' => _PASS_LONGUEUR_MINI)) : (strlen($login) < _LOGIN_TROP_COURT ? _T('info_login_trop_court') : ''));
include_spip('inc/filtres');
if (!$echec and $email and !email_valide($email)) {
$echec = _T('form_email_non_valide');
}
if ($echec) {
echo minipres('AUTO', info_progression_etape(3, 'etape_', 'install/', true) . "<div class='error'><h3>{$echec}</h3>\n" . "<p>" . _T('avis_connexion_echec_2') . "</p>" . "</div>");
exit;
}
}
if (@file_exists(_FILE_CHMOD_TMP)) {
include _FILE_CHMOD_TMP;
} else {
redirige_url_ecrire('install');
}
if (!@file_exists(_FILE_CONNECT_TMP)) {
redirige_url_ecrire('install');
}
# maintenant on connait le vrai charset du site s'il est deja configure
# sinon par defaut lire_meta reglera _DEFAULT_CHARSET
# (les donnees arrivent de toute facon postees en _DEFAULT_CHARSET)
lire_metas();
if ($login) {
include_spip('inc/charsets');
$nom = importer_charset($nom, _DEFAULT_CHARSET);
$login = importer_charset($login, _DEFAULT_CHARSET);
$email = importer_charset($email, _DEFAULT_CHARSET);
# pour le passwd, bizarrement il faut le convertir comme s'il avait
# ete tape en iso-8859-1 ; car c'est en fait ce que voit md5.js
$pass = unicode2charset(utf_8_to_unicode($pass), 'iso-8859-1');
include_spip('auth/sha256.inc');
include_spip('inc/acces');
$htpass = generer_htpass($pass);
$alea_actuel = creer_uniqid();
$alea_futur = creer_uniqid();
$shapass = _nano_sha256($alea_actuel . $pass);
// prelablement, creer le champ webmestre si il n'existe pas (install neuve
// sur une vieille base
$t = sql_showtable("spip_auteurs", true);
if (!isset($t['field']['webmestre'])) {
@sql_alter("TABLE spip_auteurs ADD webmestre varchar(3) DEFAULT 'non' NOT NULL");
}
$id_auteur = sql_getfetsel("id_auteur", "spip_auteurs", "login="******"nom" => $nom, 'email' => $email, 'login' => $login, 'pass' => $shapass, 'alea_actuel' => $alea_actuel, 'alea_futur' => $alea_futur, 'htpass' => $htpass, 'statut' => '0minirezo'), "id_auteur={$id_auteur}");
} else {
$id_auteur = sql_insertq('spip_auteurs', array('nom' => $nom, 'email' => $email, 'login' => $login, 'pass' => $shapass, 'htpass' => $htpass, 'alea_actuel' => $alea_actuel, 'alea_futur' => $alea_futur, 'statut' => '0minirezo'));
}
// le passer webmestre separrement du reste, au cas ou l'alter n'aurait pas fonctionne
@sql_updateq('spip_auteurs', array('webmestre' => 'oui'), "id_auteur={$id_auteur}");
// inserer email comme email webmaster principal
// (sauf s'il est vide: cas de la re-installation)
if ($email) {
ecrire_meta('email_webmaster', $email);
}
// Connecter directement celui qui vient de (re)donner son login
// mais sans cookie d'admin ni connexion longue
include_spip('inc/auth');
if (!($auteur = auth_identifier_login($login, $pass)) or !auth_loger($auteur, true)) {
spip_log("login automatique impossible {$auth_spip} {$session}" . count($row));
}
}
// installer les metas
$config = charger_fonction('config', 'inc');
$config();
// activer les plugins
// leur installation ne peut pas se faire sur le meme hit, il faudra donc
// poursuivre au hit suivant
include_spip('inc/plugin');
actualise_plugins_actifs();
include_spip('inc/distant');
redirige_par_entete(parametre_url(self(), 'etape', '4', '&'));
}
function csv2auteurs_exportation()
{
//récupération des noms des champs
$nom_champs = array();
$champ_supprimer = array(0, 8, 15, 16, 17, 18, 19);
$desc = sql_showtable('spip_auteurs', true);
foreach ($desc[field] as $cle => $valeur) {
$nom_champs[$cle] = "-> {$cle}";
}
foreach ($champ_supprimer as $cle) {
unset($nom_champs[$cle]);
}
return $nom_champs;
}
/**
* @return string
*/
function spiplistes_base_creer () {
//spiplistes_debug_log("spiplistes_base_creer()");
global $tables_principales;
// demande a SPIP de creer les tables (base/create.php)
include_spip('base/create');
include_spip('base/abstract_sql');
include_spip('base/db_mysql');
include_spip('base/spiplistes_tables');
creer_base();
$descauteurs = sql_showtable('spip_auteurs_elargis',true);
if(!isset($descauteurs['field']['spip_listes_format'])){
// si la table spip_auteurs_elargis existe déjà
sql_alter("TABLE spip_auteurs_elargis ADD `spip_listes_format` VARCHAR(8) DEFAULT 'non' NOT NULL");
}
spiplistes_log("INSTALL: database creation");
$spiplistes_base_version = spiplistes_real_version_base_get(_SPIPLISTES_PREFIX);
ecrire_meta('spiplistes_base_version', $spiplistes_base_version);
spiplistes_ecrire_metas();
$spiplistes_base_version = $GLOBALS['meta']['spiplistes_base_version'];
return($spiplistes_base_version);
}
/**
* Retourne la description d'une table SQL
*
* Cela sert notamment au moment de la compilation des boucles, critères et balise.
*
* Les champs et clés de la tables sont retrouvés prioritairement via le
* gestionnaire de base de données. Les descriptions sont complétées,
* pour les tables éditoriales, des informations déclarées ou construites
* par la déclaration des objets éditoriaux.
*
* @example
* $trouver_table = charger_fonction('trouver_table', 'base');
* $desc = $trouver_table('spip_groupes_mots');
*
* Cette fonction intervient à la compilation, mais aussi pour la balise
* contextuelle EXPOSE ou certains critères.
*
* L'ensemble des descriptions de table d'un serveur est stocké dans un
* fichier cache/sql_desc.txt par soucis de performance. Un appel
* avec $nom vide est une demande explicite de vidange de ce cache
*
* @see lister_tables_objets_sql()
*
* @api
* @param string $nom
* Nom de la table
* Vide '' demande de vider le cache des discriptions
* @param string $serveur
* Nom du connecteur
* @param bool $table_spip
* Indique s'il faut transformer le préfixe de table
* @return array|bool
* false si table introuvable
* tableau de description de la table sinon, en particulier :
* - field : tableau des colonnes SQL et leur description (comme dans serial.php ou objets.php)
* - key : tableau des KEY (comme dans serial.php ou objets.php)
* - table et table_sql : nom de la table (avec spip_ en préfixe)
* - id_table : nom SPIP de la table (type de boucle)
* le compilateur produit FROM $r['table'] AS $r['id_table']
* - Toutes les autres informations des objets éditoriaux si la table est l'un d'eux.
*
*
**/
function base_trouver_table_dist($nom, $serveur = '', $table_spip = true)
{
static $nom_cache_desc_sql = array();
if (!spip_connect($serveur) or !preg_match('/^[a-zA-Z0-9._-]*/', $nom)) {
return null;
}
$connexion =& $GLOBALS['connexions'][$serveur ? strtolower($serveur) : 0];
$objets_sql = lister_tables_objets_sql("::md5");
// le nom du cache depend du serveur mais aussi du nom de la db et du prefixe
// ce qui permet une auto invalidation en cas de modif manuelle du fichier
// de connexion, et tout risque d'ambiguite
if (!isset($nom_cache_desc_sql[$serveur][$objets_sql])) {
$nom_cache_desc_sql[$serveur][$objets_sql] = _DIR_CACHE . 'sql_desc_' . ($serveur ? "{$serveur}_" : "") . substr(md5($connexion['db'] . ":" . $connexion['prefixe'] . ":{$objets_sql}"), 0, 8) . '.txt';
// nouveau nom de cache = nouvelle version en memoire
unset($connexion['tables']);
}
// un appel avec $nom vide est une demande explicite de vidange du cache des descriptions
if (!$nom) {
spip_unlink($nom_cache_desc_sql[$serveur][$objets_sql]);
$connexion['tables'] = array();
return null;
}
$nom_sql = $nom;
if (preg_match('/\\.(.*)$/', $nom, $s)) {
$nom_sql = $s[1];
} else {
$nom_sql = $nom;
}
$fdesc = $desc = '';
$connexion =& $GLOBALS['connexions'][$serveur ? $serveur : 0];
// base sous SPIP: gerer les abreviations explicites des noms de table
if ($connexion['spip_connect_version']) {
if ($table_spip and isset($GLOBALS['table_des_tables'][$nom])) {
$nom = $GLOBALS['table_des_tables'][$nom];
$nom_sql = 'spip_' . $nom;
}
}
// si c'est la premiere table qu'on cherche
// et si on est pas explicitement en recalcul
// on essaye de recharger le cache des decriptions de ce serveur
// dans le fichier cache
if (!isset($connexion['tables'][$nom_sql]) and defined('_VAR_MODE') and _VAR_MODE !== 'recalcul' and (!isset($connexion['tables']) or !$connexion['tables'])) {
if (lire_fichier($nom_cache_desc_sql[$serveur][$objets_sql], $desc_cache) and $desc_cache = unserialize($desc_cache)) {
$connexion['tables'] = $desc_cache;
}
}
if ($table_spip and !isset($connexion['tables'][$nom_sql])) {
if (isset($GLOBALS['tables_principales'][$nom_sql])) {
$fdesc = $GLOBALS['tables_principales'][$nom_sql];
} elseif ($nom_sql == $nom and isset($GLOBALS['tables_principales']['spip_' . $nom])) {
$nom_sql = 'spip_' . $nom;
$fdesc =& $GLOBALS['tables_principales'][$nom_sql];
} elseif (isset($GLOBALS['tables_auxiliaires'][$n = $nom]) or isset($GLOBALS['tables_auxiliaires'][$n = 'spip_' . $nom])) {
$nom_sql = $n;
$fdesc =& $GLOBALS['tables_auxiliaires'][$n];
}
# table locale a cote de SPIP, comme non SPIP:
}
if (!isset($connexion['tables'][$nom_sql])) {
// La *vraie* base a la priorite
$desc = sql_showtable($nom_sql, $table_spip, $serveur);
if (!$desc or !$desc['field']) {
if (!$fdesc) {
spip_log("trouver_table: table inconnue '{$serveur}' '{$nom}'", _LOG_INFO_IMPORTANTE);
return null;
}
// on ne sait pas lire la structure de la table :
// on retombe sur la description donnee dans les fichiers spip
$desc = $fdesc;
$desc['exist'] = false;
} else {
$desc['exist'] = true;
}
$desc['table'] = $desc['table_sql'] = $nom_sql;
$desc['connexion'] = $serveur;
// charger les infos declarees pour cette table
// en lui passant les infos connues
// $desc est prioritaire pour la description de la table
$desc = array_merge(lister_tables_objets_sql($nom_sql, $desc), $desc);
// si tables_objets_sql est bien fini d'init, on peut cacher
$connexion['tables'][$nom_sql] = $desc;
$res =& $connexion['tables'][$nom_sql];
// une nouvelle table a ete decrite
// mettons donc a jour le cache des descriptions de ce serveur
if (is_writeable(_DIR_CACHE)) {
ecrire_fichier($nom_cache_desc_sql[$serveur][$objets_sql], serialize($connexion['tables']), true);
}
} else {
$res =& $connexion['tables'][$nom_sql];
}
// toujours retourner $nom dans id_table
$res['id_table'] = $nom;
return $res;
}
function spip_pg_create_view($nom, $query_select, $serveur='',$requeter=true) {
if (!$query_select) return false;
// vue deja presente
if (sql_showtable($nom, false, $serveur)) {
if ($requeter) spip_log("Echec creation d'une vue sql ($nom) car celle-ci existe deja (serveur:$serveur)");
return false;
}
$query = "CREATE VIEW $nom AS ". $query_select;
return spip_pg_query($query, $serveur, $requeter);
}
/**
* Mise à jour de la base de données (tables SPIP-Listes uniquement)
*
* @return string
*/
function spiplistes_upgrade_base (
$spiplistes_name
, $spiplistes_current_version
, $spiplistes_current_version_base
, $spiplistes_real_version_base
) {
//spiplistes_debug_log("spiplistes_upgrade_base(),);
if($spiplistes_current_version_base && ($spiplistes_current_version_base >= $spiplistes_real_version_base)) {
// La base est a jour
return($spiplistes_current_version_base);
}
// faire la mise a jour
spiplistes_debug_log("UPGRADING DATABASE $spiplistes_name $spiplistes_current_version_base TO $spiplistes_real_version_base");
// 'version_base' n'apparait que dans SPIP-Listes 1.98001
// Cherche sur $spiplistes_version pour les versions precedentes
//install
$version_base = 1.91; // ou inferieur ?
if (
(!$spiplistes_current_version)
|| ($spiplistes_current_version < 1.98001)
) {
// si etait deja installe mais dans une vieille version, on reprend a zero
include_spip('base/abstract_sql');
$desc = sql_showtable("spip_listes",true);
if (!isset($desc['field']['id_liste']))
$current_version = 0.0;
if(
sql_getfetsel("*", 'spip_articles'
, "statut=".sql_quote('liste')." OR statut=".sql_quote('inact')." OR statut=".sql_quote('poublist'))
) {
$current_version=0.0;
}
if ($current_version==0.0){
// Verifie que les tables spip_listes existent, sinon les creer
//spiplistes_debug_log("UPGRADE: current_version: $current_version");
include_spip('base/create');
include_spip('base/abstract_sql');
//Migrer des listes anciennes // a deplacer dans une en fonction
$resultat_aff = sql_select("*", 'spip_articles'
, "statut=".sql_quote('liste')." OR statut=".sql_quote('inact')." OR statut=".sql_quote('poublist'));
if(@sql_count($resultat_aff) > 0) {
echo _T('spiplistes:mettre_a_jour');
while ($row = sql_fetch($resultat_aff)) {
$id_article=$row['id_article'];
$titre_liste=corriger_caracteres($row['titre']);
$texte_liste = corriger_caracteres($row['texte']);
$date_liste = $row['date'];
$langue=$row["lang"];
$statut = $row['statut'];
$extra=unserialize($row['extra']);
$patron_liste=$extra["squelette"];
$periode_liste=$extra["periode"];
$maj_liste=$extra["majnouv"];
$email_envoi=$extra["email_envoi"];
$message_auto=$extra["auto"];
$options="<p>".$titre_liste."<br/>";
echo $options."</p>";
// ajout du pied de page
include_spip('public/assembler');
$contexte_pied = array('lang'=>$langue);
$pied = recuperer_fond('modeles/piedmail', $contexte_pied);
$id_liste = sql_insertq(
"spip_listes"
, array(
'titre' => $titre_liste
, 'texte' => $texte_liste
, 'statut' => $statut
, 'date' => $date_liste
, 'lang' => $langue
, 'pied_page' => $pied
)
);
if($message_auto=="oui")
sql_update(
'spip_listes'
, array(
'patron' => sql_quote($patron_liste)
, 'periode' => sql_quote($periode_liste)
, 'maj' => "FROM_UNIXTIME(".sql_quote($maj_liste).")"
, 'email_envoi' => sql_quote($email_envoi)
, 'message_auto' => sql_quote($message_auto)
)
, "id_liste=".sql_quote($id_liste)
);
//Auteur de la liste (moderateur)
sql_delete('spip_auteurs_mod_listes', "id_liste =".sql_quote($id_liste));
sql_insert(
'spip_auteurs_mod_listes'
, "(id_auteur, id_liste)"
, "(".sql_quote($connect_id_auteur).",".sql_quote($id_liste).")"
);
//recuperer les abonnes (peut etre plus tard ?)
$abos = sql_select('id_auteur,id_article', 'spip_auteurs_articles'
, "id_article=".sql_quote($id_article));
while($abonnes = sql_fetch($abos)){
$abo = intval($abonnes['id_auteur']);
sql_insert('spip_auteurs_listes'
, "(id_auteur, id_liste)"
, "(".sql_quote($abo).",".sql_quote($id_liste).")"
);
}
//effacer les anciens articles/abo
sql_delete('spip_articles', "id_article =".sql_quote($id_article));
sql_delete('spip_auteurs_articles', "id_article =".sql_quote($id_article));
//manque un traitement pour recuperer les courriers
}
//evaluer les extras de tous les auteurs et les virer
$result = sql_select(
"extra AS e, spip_auteurs.id_auteur AS i"
, 'spip_auteurs'
);
while ($row = sql_fetch($result)) {
$abo = unserialize($row['e']);
$format = $abo['abo'] ;
if($format=="texte" || $format=="html") {
sql_insert(
'spip_auteurs_elargis'
, "(id_auteur,`spip_listes_format`)"
, "(".sql_quote($row['i']).",".sql_quote($format).")"
);
}
else {
sql_insert(
'spip_auteurs_elargis'
, "(id_auteur, `spip_listes_format`)"
, "(".sql_quote($row['i']).",".sql_quote('non').")"
);
}
} // end while
echo _T('spiplistes:regulariser');
$result = sql_select(
"a.email, a.id_auteur"
, "spip_auteurs AS a, spip_auteurs_listes AS l, spip_auteurs_elargis AS f"
, array(
"a.id_auteur=f.id_auteur"
, "f.spip_listes_format=".sql_quote('non')
, "a.id_auteur=l.id_auteur"
, "a.statut!=".sql_quote('5poubelle')
)
, array("email")
); //
while($res = sql_fetch($result)) {
sql_delete('spip_auteurs_listes', "id_auteur =".sql_quote($res['id_auteur'])) ;
}
} // end if(@sql_count($resultat_aff) > 0)
ecrire_meta('spiplistes_version',$current_version=$version_base,'non');
}
if ($current_version<1.92){
//spiplistes_debug_log("UPGRADE: current_version: $current_version");
echo "SpipListes Maj 1.92<br />";
sql_alter("TABLE spip_listes ADD titre_message varchar(255) NOT NULL default ''");
sql_alter("TABLE spip_listes ADD pied_page longblob NOT NULL");
ecrire_meta('spiplistes_version', $current_version=1.92);
}
if ($current_version<1.94){
//spiplistes_debug_log("UPGRADE: current_version: $current_version");
echo "SpipListes Maj 1.94<br />";
include_spip('base/abstract_sql');
if (($res = sql_select('id_auteur', 'spip_auteurs_mod_listes'))
&& (!sql_fetch($res))
&& ($desc = sql_showtable("spip_abonnes_listes",true))
&& isset($desc['field']['id_auteur'])
) {
sql_drop_table("spip_auteurs_mod_listes"); // elle vient d'etre cree par un creer_base inopportun
sql_drop_table("spip_auteurs_courriers"); // elle vient d'etre cree par un creer_base inopportun
}
sql_alter("TABLE spip_auteurs_listes RENAME spip_auteurs_mod_listes");
sql_alter("TABLE spip_abonnes_listes RENAME spip_auteurs_listes");
sql_alter("TABLE spip_abonnes_courriers RENAME spip_auteurs_courriers");
ecrire_meta('spiplistes_version', $current_version=1.94);
}
if ($current_version<1.95){
//spiplistes_debug_log("UPGRADE: current_version: $current_version");
echo "SpipListes Maj 1.95<br />";
include_spip('base/abstract_sql');
sql_alter("TABLE spip_auteurs_courriers ADD etat varchar(5) NOT NULL default '' AFTER statut");
ecrire_meta('spiplistes_version', $current_version=1.95);
}
if ($current_version<1.96){
//spiplistes_debug_log("UPGRADE: current_version: $current_version");
echo "SpipListes Maj 1.96<br />";
include_spip('base/abstract_sql');
//installer la table spip_auteurs_elargis si besoin
$table_nom = "spip_auteurs_elargis";
sql_query("CREATE TABLE IF NOT EXISTS ".$table_nom." (
`id_auteur` BIGINT NOT NULL ,
`spip_listes_format` VARCHAR( 8 ) DEFAULT 'non' NOT NULL
) ");
//evaluer les extras de tous les auteurs + compter tous les auteurs
$result = sql_select(
"extra AS e,spip_auteurs.id_auteur AS i"
, 'spip_auteurs');
$nb_inscrits = 0;
//repartition des extras
$cmpt = array('texte'=>0, 'html'=>0, 'non'=>0);
while ($row = sql_fetch($result)) {
$nb_inscrits++ ;
$abo = unserialize($row['e']);
$format = $abo['abo'] ;
if($format=="texte" || $format=="html") {
sql_insert(
'spip_auteurs_elargis'
, "(id_auteur, `spip_listes_format`)"
, "(".sql_quote($row['i']).",".sql_quote($format).")"
);
}
else {
sql_insert(
'spip_auteurs_elargis'
, "(id_auteur, `spip_listes_format`)"
, "(".sql_quote($row['i']).",".sql_quote('non').") "
);
}
if ($abo['abo']) {
$cmpt[$abo['abo']] ++;
}
}
echo "<br />html : ".$cmpt['html']." <br />texte : ".$cmpt['texte']."<br />non : ".$cmpt['non']."<br />somme :".$nb_inscrits ;
ecrire_meta('spiplistes_version', $current_version=1.96);
}
if ($current_version<1.97) {
//spiplistes_debug_log("UPGRADE: current_version: $current_version");
echo "SpipListes Maj 1.97<br />";
include_spip('base/abstract_sql');
echo "regulariser les desabonnes avec listes...<br />";
$result = sql_select(
"a.email,a.id_auteur"
, "spip_auteurs AS a, spip_auteurs_listes AS l, spip_auteurs_elargis AS f"
, array(
"a.id_auteur=f.id_auteur"
, "f.spip_listes_format=".sql_quote('non')
, "a.id_auteur=l.id_auteur"
, "a.statut!=".sql_quote('5poubelle' )
)
, array("email")
); //
$nb_inscrits = sql_count($result);
echo($nb_inscrits);
while($res = sql_fetch($result)) {
sql_delete("spip_auteurs_listes", "id_auteur =".sql_quote($res['id_auteur'])) ;
}
ecrire_meta('spiplistes_version', $current_version=1.97);
} // end if ($current_version<1.97)
if ($current_version<1.98) {
echo "SpipListes Maj 1.98<br />";
include_spip('base/abstract_sql');
echo "regulariser l'index";
$table_nom = "spip_auteurs_elargis";
//ajout des index
$desc = sql_showtable($table_nom,true);
if($desc['key']['PRIMARY KEY']!='id'){
sql_alter("TABLE ".$table_nom." DROP PRIMARY KEY");
if(!isset($desc['fields']['id'])) {
sql_alter("TABLE ".$table_nom." ADD id INT NOT NULL AUTO_INCREMENT PRIMARY KEY");
}
else {
sql_alter("TABLE ".$table_nom." ADD PRIMARY KEY (id)");
}
}
if($desc['key']['KEY id_auteur']) {
sql_alter("TABLE ".$table_nom." DROP INDEX id_auteur, ADD INDEX id_auteur (id_auteur)");
}
else {
sql_alter("TABLE ".$table_nom." ADD INDEX id_auteur (id_auteur)");
}
ecrire_meta('spiplistes_version', $current_version=1.98);
}
spiplistes_ecrire_metas();
}
// A partir de SPIP-Listes 1.98001, on se base sur le vrai numero de version de
// la base, (plugin.xml: <version_base>)
if($spiplistes_current_version_base < $spiplistes_real_version_base) {
spiplistes_debug_log("UPGRADING DATABASE version_base: $spiplistes_current_version_base TO $spiplistes_real_version_base");
/* ... */
// ajouter au dessus de cette ligne les patches si besoin pour nouvelle version de la base
// fin des ajouts de patches
ecrire_meta('spiplistes_base_version', $spiplistes_current_version_base);
spiplistes_ecrire_metas();
}
return($spiplistes_current_version_base);
}
/**
* Preparer la table dans la base de destination :
* la droper si elle existe (sauf si auteurs ou meta sur le serveur principal)
* la creer si necessaire, ou ajouter simplement les champs manquants
*
* @param string $table
* @param array $desc
* @param string $serveur_dest
* @param bool $init
* @return array
*/
function base_preparer_table_dest($table, $desc, $serveur_dest, $init = false)
{
$upgrade = false;
// si la table existe et qu'on est a l'init, la dropper
if ($desc_dest = sql_showtable($table, true, $serveur_dest) and $init) {
if ($serveur_dest == '' and in_array($table, array('spip_meta', 'spip_auteurs'))) {
// ne pas dropper auteurs et meta sur le serveur principal
// faire un simple upgrade a la place
// pour ajouter les champs manquants
$upgrade = true;
// coherence avec le drop sur les autres tables
base_vider_tables_destination_copie(array($table), array(), $serveur_dest);
if ($table == 'spip_meta') {
// virer les version base qui vont venir avec l'import
sql_delete($table, "nom like '%_base_version'", $serveur_dest);
// hum casse la base si pas version_installee a l'import ...
sql_delete($table, "nom='version_installee'", $serveur_dest);
}
} else {
sql_drop_table($table, '', $serveur_dest);
spip_log("drop table '{$table}' sur serveur '{$serveur_dest}'", 'dump.' . _LOG_INFO_IMPORTANTE);
}
$desc_dest = false;
}
// si la table n'existe pas dans la destination, la creer a l'identique !
if (!$desc_dest) {
spip_log("creation '{$table}' sur serveur '{$serveur_dest}'", 'dump.' . _LOG_INFO_IMPORTANTE);
include_spip('base/create');
creer_ou_upgrader_table($table, $desc, 'auto', $upgrade, $serveur_dest);
$desc_dest = sql_showtable($table, true, $serveur_dest);
}
if (!$desc_dest) {
spip_log("Erreur creation '{$table}' sur serveur '{$serveur_dest}'" . var_export($desc, 1), 'dump.' . _LOG_ERREUR);
}
return $desc_dest;
}
/**
* Gestion des requêtes ALTER non reconnues de SQLite
*
* Requêtes non reconnues :
*
* ALTER TABLE table DROP column
* ALTER TABLE table CHANGE [COLUMN] columnA columnB definition
* ALTER TABLE table MODIFY column definition
* ALTER TABLE table ADD|DROP PRIMARY KEY
*
* `MODIFY` est transformé en `CHANGE columnA columnA` par spip_sqlite_alter()
*
* 1) Créer une table B avec le nouveau format souhaité
* 2) Copier la table d'origine A vers B
* 3) Supprimer la table A
* 4) Renommer la table B en A
* 5) Remettre les index (qui sont supprimés avec la table A)
*
* @param string|array $table
* - string : Nom de la table table,
* - array : couple (nom de la table => nom futur)
* @param string|array $colonne
* - string : nom de la colonne,
* - array : couple (nom de la colonne => nom futur)
* @param array $opt
* options comme les tables SPIP, qui sera mergé à la table créee :
* `array('field'=>array('nom'=>'syntaxe', ...), 'key'=>array('KEY nom'=>'colonne', ...))`
* @param string $serveur
* Nom de la connexion SQL en cours
* @return bool
* true si OK, false sinon.
*/
function _sqlite_modifier_table($table, $colonne, $opt = array(), $serveur = '')
{
if (is_array($table)) {
reset($table);
list($table_origine, $table_destination) = each($table);
} else {
$table_origine = $table_destination = $table;
}
// ne prend actuellement qu'un changement
// mais pourra etre adapte pour changer plus qu'une colonne a la fois
if (is_array($colonne)) {
reset($colonne);
list($colonne_origine, $colonne_destination) = each($colonne);
} else {
$colonne_origine = $colonne_destination = $colonne;
}
if (!isset($opt['field'])) {
$opt['field'] = array();
}
if (!isset($opt['key'])) {
$opt['key'] = array();
}
// si les noms de tables sont differents, pas besoin de table temporaire
// on prendra directement le nom de la future table
$meme_table = $table_origine == $table_destination;
$def_origine = sql_showtable($table_origine, false, $serveur);
if (!$def_origine or !isset($def_origine['field'])) {
spip_log("Alter table impossible sur {$table_origine} : table non trouvee", 'sqlite' . _LOG_ERREUR);
return false;
}
$table_tmp = $table_origine . '_tmp';
// 1) creer une table temporaire avec les modifications
// - DROP : suppression de la colonne
// - CHANGE : modification de la colonne
// (foreach pour conserver l'ordre des champs)
// field
$fields = array();
// pour le INSERT INTO plus loin
// stocker la correspondance nouvelles->anciennes colonnes
$fields_correspondances = array();
foreach ($def_origine['field'] as $c => $d) {
if ($colonne_origine && $c == $colonne_origine) {
// si pas DROP
if ($colonne_destination) {
$fields[$colonne_destination] = $opt['field'][$colonne_destination];
$fields_correspondances[$colonne_destination] = $c;
}
} else {
$fields[$c] = $d;
$fields_correspondances[$c] = $c;
}
}
// cas de ADD sqlite2 (ajout du champ en fin de table):
if (!$colonne_origine && $colonne_destination) {
$fields[$colonne_destination] = $opt['field'][$colonne_destination];
}
// key...
$keys = array();
foreach ($def_origine['key'] as $c => $d) {
$c = str_replace($colonne_origine, $colonne_destination, $c);
$d = str_replace($colonne_origine, $colonne_destination, $d);
// seulement si on ne supprime pas la colonne !
if ($d) {
$keys[$c] = $d;
}
}
// autres keys, on merge
$keys = array_merge($keys, $opt['key']);
$queries = array();
// copier dans destination (si differente de origine), sinon tmp
$table_copie = $meme_table ? $table_tmp : $table_destination;
$autoinc = (isset($keys['PRIMARY KEY']) and $keys['PRIMARY KEY'] and stripos($keys['PRIMARY KEY'], ',') === false and stripos($fields[$keys['PRIMARY KEY']], 'default') === false);
if ($q = _sqlite_requete_create($table_copie, $fields, $keys, $autoinc, $temporary = false, $ifnotexists = true, $serveur)) {
$queries[] = $q;
}
// 2) y copier les champs qui vont bien
$champs_dest = join(', ', array_keys($fields_correspondances));
$champs_ori = join(', ', $fields_correspondances);
$queries[] = "INSERT INTO {$table_copie} ({$champs_dest}) SELECT {$champs_ori} FROM {$table_origine}";
// 3) supprimer la table d'origine
$queries[] = "DROP TABLE {$table_origine}";
// 4) renommer la table temporaire
// avec le nom de la table destination
// si necessaire
if ($meme_table) {
if (_sqlite_is_version(3, '', $serveur)) {
$queries[] = "ALTER TABLE {$table_copie} RENAME TO {$table_destination}";
} else {
$queries[] = _sqlite_requete_create($table_destination, $fields, $keys, $autoinc, $temporary = false, $ifnotexists = false, $serveur);
$queries[] = "INSERT INTO {$table_destination} SELECT * FROM {$table_copie}";
$queries[] = "DROP TABLE {$table_copie}";
}
}
// 5) remettre les index !
foreach ($keys as $k => $v) {
if ($k == 'PRIMARY KEY') {
} else {
// enlever KEY
$k = substr($k, 4);
$queries[] = "CREATE INDEX {$table_destination}" . "_{$k} ON {$table_destination} ({$v})";
}
}
if (count($queries)) {
spip_sqlite::demarrer_transaction($serveur);
// il faut les faire une par une car $query = join('; ', $queries).";"; ne fonctionne pas
foreach ($queries as $q) {
if (!spip_sqlite::executer_requete($q, $serveur)) {
spip_log(_LOG_GRAVITE_ERREUR, "SQLite : ALTER TABLE table :" . " Erreur a l'execution de la requete : {$q}", 'sqlite');
spip_sqlite::annuler_transaction($serveur);
return false;
}
}
spip_sqlite::finir_transaction($serveur);
}
return true;
}
/**
*
* @param <type> $creer
* @return <type>
*/
function verifier_colonne($creer = false) {
if (!$this->param['table'])
return false;
$col = sql_showtable($table = $this->param['table']);
if (!is_array($col['field']) OR !array_key_exists($colonne = $this->param['colonne'], $col['field'])) {
if ($creer
&& $colonne
&& sql_alter('TABLE '.$this->param['table'] . ' ADD ' . $colonne . 'TEXT NOT NULL DEFAULT \'\'')) {
return true;
}
return false;
}
return true;
}
/**
* Liste les champs dispos dans la table SQL de la connexion sql donnée
*
* @param string $table
* Nom de la table SQL
* @param string $connect
* Nom du connecteur de base de données
* @return array
* Couples (colonne => description SQL)
*/
function extras_champs($table, $connect)
{
$desc = sql_showtable($table, true, $connect);
if (is_array($desc['field'])) {
return $desc['field'];
} else {
return array();
}
}
if (!isset($extras[$table]) or !is_array($extras[$table])) {
$extras[$table] = array();
}
$extras[$table][$te['champ']] = $te;
}
unset($oextras);
$nsaisie = array('bloc' => 'textarea', 'ligne' => 'input', 'auteur' => 'auteurs', 'auteurs' => 'auteurs', 'oui-non' => 'oui_non', 'menu-radio' => 'radio', 'menu-enum' => 'selection', 'menu-cases' => 'checkbox');
include_spip('inc/saisies');
include_spip('inc/config');
// stocker les extras qui n'ont pas été importés totalement
$reste = array();
// pour chaque table sql
foreach ($extras as $table => $champs) {
// on recupere les champs extras declares pour la nouvelle version
$ici = isset($GLOBALS['meta']['champs_extras_' . $table]) ? unserialize($GLOBALS['meta']['champs_extras_' . $table]) : array();
$desc = sql_showtable($table);
#var_dump($table, $ici);
# var_dump($champs);
// pour chaque champs extras decrits
foreach ($champs as $champ => $extra) {
// si la colonne SQL n'existe pas, on passe
if (!isset($desc['field'][$champ])) {
unset($champs[$champ]);
continue;
}
// si le champs est deja decrit dans la nouvelle structure, on passe
foreach ($ici as $c) {
if ($c['options']['nom'] == $champ) {
unset($champs[$champ]);
continue 2;
}
/**
* Preparer la table dans la base de destination :
* la droper si elle existe (sauf si auteurs ou meta sur le serveur principal)
* la creer si necessaire, ou ajouter simplement les champs manquants
*
* @param string $table
* @param array $desc
* @param string $serveur_dest
* @param bool $init
* @return array
*/
function base_preparer_table_dest($table, $desc, $serveur_dest, $init=false) {
$upgrade = false;
// si la table existe et qu'on est a l'init, la dropper
if ($desc_dest=sql_showtable($table,true,$serveur_dest) AND $init) {
if ($serveur_dest=='' AND in_array($table,array('spip_meta','spip_auteurs'))) {
// ne pas dropper auteurs et meta sur le serveur principal
// faire un simple upgrade a la place
// pour ajouter les champs manquants
$upgrade = true;
// coherence avec le drop sur les autres tables
base_vider_tables_destination_copie(array($table),array(),$serveur_dest);
if ($table=='spip_meta'){
// virer les version base qui vont venir avec l'import
sql_delete($table, "nom like '%_base_version'",$serveur_dest);
// hum casse la base si pas version_installee a l'import ...
sql_delete($table, "nom='version_installee'",$serveur_dest);
}
}
else {
sql_drop_table($table, '', $serveur_dest);
spip_log( "drop table '$table' sur serveur '$serveur_dest'",'dump.'._LOG_INFO_IMPORTANTE);
}
$desc_dest = false;
}
// si la table n'existe pas dans la destination, la creer a l'identique !
if (!$desc_dest) {
spip_log( "creation '$table' sur serveur '$serveur_dest'",'dump.'._LOG_INFO_IMPORTANTE);
include_spip('base/create');
// on fait la detection d'autoinc ici car creer_ou_upgrader_table ne sait pas forcement le faire
// (depend de la version de SPIP)
if (isset($GLOBALS['tables_principales'][$table]))
$autoinc = true;
elseif (isset($GLOBALS['tables_auxiliaires'][$table]))
$autoinc = false;
else {
// essayer de faire au mieux !
$autoinc = (isset($desc['key']['PRIMARY KEY'])
AND strpos($desc['key']['PRIMARY KEY'],',')===false
AND strpos($desc['field'][$desc['key']['PRIMARY KEY']],'default')===false);
}
creer_ou_upgrader_table($table, $desc, $autoinc, $upgrade,$serveur_dest);
$desc_dest = sql_showtable($table,false,$serveur_dest);
// si c'est une table de liens ancienne mode il faut aussi vider xx_liens si elle existe
// (migration d'un SPIP 2 vers un SPIP 3 peuple)
if (preg_match(",^spip_(auteurs|documents|mots)_(\w+)$,",$table,$m)
AND $m[2]!="liens"){
base_vider_tables_destination_copie(array("spip_".$m[1]."_liens"),array(),$serveur_dest);
}
}
if (!$desc_dest){
spip_log( "Erreur creation '$table' sur serveur '$serveur_dest'".var_export($desc,1),'dump.'._LOG_ERREUR);
}
return $desc_dest;
}
function afaire_ticket_existe($bidon)
{
$existe = false;
// Test si la table existe
$table = sql_showtable('spip_tickets', true);
if ($table) {
// Nombre total de tickets
$from = array('spip_tickets AS t1');
$where = array();
$result = sql_countsel($from, $where);
// Nombre de tickets termines pour le jalon
if ($result >= 1) {
$existe = true;
}
}
return $existe;
}
function &crayons_get_table($type, &$nom_table)
{
list($distant, $table) = distant_table($type);
static $return = array();
static $noms = array();
if (!isset($return[$table])) {
$try = array(table_objet_sql($table), 'spip_' . table_objet($table), 'spip_' . $table . 's', $table . 's', 'spip_' . $table, $table);
// premiere possibilite (à partir de 1.9.3) : regarder directement la base
if (function_exists('sql_showtable')) {
foreach ($try as $nom) {
if ($q = sql_showtable($nom, !$distant, $distant)) {
$noms[$table] = $nom;
$return[$table] = $q;
break;
}
}
}
// seconde, une heuristique 1.9.2
if (!isset($return[$table])) {
include_spip('base/serial');
include_spip('base/auxiliaires');
include_spip('public/parametrer');
foreach (array('tables_principales', 'tables_auxiliaires') as $categ) {
foreach ($try as $nom) {
if (isset($GLOBALS[$categ][$nom])) {
$noms[$table] = $nom;
$return[$table] =& $GLOBALS[$categ][$nom];
break 2;
}
}
}
}
}
$nom_table = $noms[$table];
return $return[$table];
}
function formulaires_csv2auteurs_importation_traiter_dist()
{
$maj_utilisateur = _request('maj_utilisateur');
$abs_redacs = _request('abs_redac');
$abs_admins = _request('abs_admin');
$abs_visiteurs = _request('abs_visiteur');
$abs_poubelle = _request('abs_poubelle');
$suppression_article_efface = _request('suppression_article_efface');
$traitement_article_efface = _request('traitement_article_efface');
$nom_rubrique_archive = _request('nom_rubrique_archive');
$type_maj = _request('type_maj');
// recuperation de l'id de la rubrique parent des rubriques admins
$id_rubrique_parent_admin = _request('rubrique_parent');
$id_rubrique_parent_admin = explode('|', $id_rubrique_parent_admin[0]);
$id_rubrique_parent_admin = $id_rubrique_parent_admin[1];
//récupération de l'id de la rubrique parent archive
$id_rubrique_parent_archive = _request('rubrique_parent_archive');
$id_rubrique_parent_archive = explode('|', $id_rubrique_parent_archive[0]);
$id_rubrique_parent_archive = $id_rubrique_parent_archive[1];
$retour = array();
include_spip('action/editer_rubrique');
if (test_plugin_actif("accesrestreint")) {
include_spip('action/editer_zone');
}
include_spip('action/editer_auteur');
if ($abs_redacs or $abs_admins or $abs_visiteurs or $abs_poubelle == 'supprimer') {
include_spip('action/editer_objet');
include_spip('action/editer_liens');
include_spip('action/editer_zone');
}
// récupération du fichier csv
include_spip('inc/config');
$separateur = lire_config("csv2auteurs_separateur");
$tmp_name = $_FILES['fichier_csv']['tmp_name'];
$destination = _DIR_TMP . basename($tmp_name);
$resultat = move_uploaded_file($tmp_name, $destination);
if (!$resultat) {
$retour['message_erreur'] = _T('csv2auteurs:transfert');
} else {
$retour['message_ok'] = _T('csv2auteurs:bravo');
}
// transformation du fichier csv en 4 array :
// $en_tete = ligne entete
// pour les 3 tableaux suivant, la cle est soit le login et s'il n'existe pas on prend le mail
// $tableau_csv_visiteurs
// $tableau_csv_redacs
// $tableau_csv_admins
$tableau_csv_visiteurs = $tableau_csv_redacs = $tableau_csv_admins = array();
$tableau_csv_rubriques_admins = array();
$fichiercsv = fopen($destination, "r");
$i = 0;
// correspondance statut spip / statut csv
$Tcorrespondances = array('administrateur' => '0minirezo', 'redacteur' => '1comite', 'visiteur' => '6forum', 'poubelle' => '5poubelle');
// tableau de tous les admins
$result = sql_select(array('login'), 'spip_auteurs', array('statut = "0minirezo"'));
while ($r = sql_fetch($result)) {
$Tadmin_tous[] = $r['login'];
}
// tableau des admins restreints
$Tadmin_restreint = array();
$from = array("spip_auteurs AS auteurs", "spip_auteurs_liens AS liens");
$where = array("auteurs.statut = '0minirezo'", "liens.objet = 'rubrique'", "liens.id_auteur = auteurs.id_auteur", 'login!=""');
$result = sql_select(array('login'), $from, $where);
while ($r = sql_fetch($result)) {
$Tadmin_restreint[] = $r['login'];
}
// tableau admins complets
$Tadmin_complet = array_diff($Tadmin_tous, $Tadmin_restreint);
// traiter fichier CSV
$num_statut = $num_login = -1;
while (($data = fgetcsv($fichiercsv, "{$separateur}")) !== FALSE) {
// petit hack car fgetcsv ne reconnait pas le ~ comme séparateur !!!
$data = implode("{$separateur}", $data);
$data = explode("{$separateur}", $data);
$nombre_elements = count($data);
if ($i == 0) {
for ($j = 0; $j < $nombre_elements; $j++) {
$en_tete[$j] = strtolower($data[$j]);
//Récupération de la ligne d'entete
if ($en_tete[$j] == 'statut') {
$num_statut = $j;
}
if ($en_tete[$j] == 'login') {
$num_login = $j;
}
}
if ($num_statut < 0 or $num_login < 0) {
$retour['message_erreur'] = _T('csv2auteurs:champ_manquant') . ' login:'******' statut' . $num_statut;
return $retour;
}
} else {
for ($j = 0; $j < $nombre_elements; $j++) {
// on ne veut pas les auteurs du CSV ayant login égal à celui d'un admin complet
if ($data[$num_login] and !in_array($data[$num_login], $Tadmin_complet)) {
// creation du tableau contenant l'ensemble des données à importer
if ($Tcorrespondances[strtolower($data[$num_statut])] == '6forum') {
$tableau_csv_visiteurs[$data[$num_login]][$en_tete[$j]] = $en_tete[$j] == "statut" ? "6forum" : $data[$j];
}
if ($Tcorrespondances[strtolower($data[$num_statut])] == '1comite') {
$tableau_csv_redacs[$data[$num_login]][$en_tete[$j]] = $en_tete[$j] == "statut" ? "1comite" : $data[$j];
}
if ($Tcorrespondances[strtolower($data[$num_statut])] == '0minirezo') {
$tableau_csv_admins[$data[$num_login]][$en_tete[$j]] = $en_tete[$j] == "statut" ? "0minirezo" : $data[$j];
if ($en_tete[$j] == 'ss_groupe' and $data[$j]) {
$Trub = explode('|', $data[$j]);
foreach ($Trub as $rub) {
if (!in_array($rub, $tableau_csv_rubriques_admins)) {
$tableau_csv_rubriques_admins[] = $rub;
}
}
}
}
}
}
}
$i++;
}
fclose($fichiercsv);
unlink($destination);
// tableau CSV total
$tableau_csv_total = $tableau_csv_visiteurs + $tableau_csv_redacs + $tableau_csv_admins;
// echo "<pre>";
// print_r($tableau_csv_visiteurs);
// echo "admi";
// print_r($tableau_csv_admins);
// echo "red";
// print_r($tableau_csv_redacs);
// print_r($tableau_csv_total);die;
//spip_log("tableau csv total","csvspip");
//spip_log($tableau_csv_total,"csvspip");
//récupération des auteurs de la bdd en 4 array
// on ne prend pas les auteurs sans login
// $poubelle_bdd = les auteurs à la poubelle
// $visiteur_bdd = les visiteurs
// $redacteur_bdd
// $admin_restreint_bdd
// la cle de chaque tableau est le login
$poubelle_bdd = $visiteur_bdd = $redacteur_bdd = $admin_restreint_bdd = array();
/* $poubelle_bdd_req = sql_allfetsel('*', 'spip_auteurs',array('statut="5poubelle"','(login!="")'));
foreach ($poubelle_bdd_req as $key) {
$poubelle_bdd[$key['login']]=$key;
}
*/
$visiteur_bdd_req = sql_allfetsel('*', 'spip_auteurs', array('statut="6forum"', '(login!="")'));
foreach ($visiteur_bdd_req as $key) {
$visiteur_bdd[$key['login']] = $key;
}
$redacteur_bdd_req = sql_allfetsel('*', 'spip_auteurs', array('statut="1comite"', '(login!="")'));
foreach ($redacteur_bdd_req as $key) {
$redacteur_bdd[$key['login']] = $key;
}
//on récupère seulement les admins restreints !!!
$from = array("spip_auteurs AS auteurs", "spip_auteurs_liens AS liens");
$where = array("auteurs.statut = '0minirezo'", "liens.objet = 'rubrique'", "liens.id_auteur = auteurs.id_auteur", '(login!="")');
$admin_restreint_bdd_req = sql_allfetsel("DISTINCT auteurs.*", $from, $where);
foreach ($admin_restreint_bdd_req as $key) {
$admin_restreint_bdd[$key['login']] = $key;
}
// tableau BDD total
$tableau_bdd_total = $poubelle_bdd + $visiteur_bdd + $redacteur_bdd + $admin_restreint_bdd;
// traitement rubriques admin
// construction du tableau de correspondance nom_rubrique avec leur id
// création des rubriques n'existant pas
$tableau_bdd_rubriques_admins = array();
$result = sql_select(array('id_rubrique', 'titre'), 'spip_rubriques');
while ($row = sql_fetch($result)) {
$tableau_bdd_rubriques_admins[$row['id_rubrique']] = strtolower($row['titre']);
}
// traitement zones
// construction du tableau de correspondance nom_zone avec leur id
$tableau_bdd_zones_admins = array();
if (test_plugin_actif("accesrestreint")) {
$result = sql_select(array('id_zone', 'titre'), 'spip_zones');
while ($row = sql_fetch($result)) {
$tableau_bdd_zones_admins[$row['id_zone']] = strtolower($row['titre']);
}
}
spip_log($tableau_bdd_zones_admins, "csvspip");
// créer les rubriques admins du csv n'existant pas et les indexer
foreach ($tableau_csv_rubriques_admins as $id_rub => $rub) {
if (!in_array(strtolower($rub), $tableau_bdd_rubriques_admins)) {
$set = array('titre' => $rub);
$id_rub = rubrique_inserer($id_rubrique_parent_admin);
rubrique_modifier($id_rub, $set);
$tableau_bdd_rubriques_admins[$id_rub] = strtolower($rub);
}
}
//Récuperer les champs de la table auteurs
$Tnom_champs_bdd = array();
$desc = sql_showtable('spip_auteurs', true);
foreach ($desc['field'] as $cle => $valeur) {
$Tnom_champs_bdd[] = $cle;
}
// PARTIE I : maj ou ajout des auteurs
$tableau_nouveaux_auteurs = array_diff_key($tableau_csv_total, $tableau_bdd_total);
// si maj demandée
if ($maj_utilisateur) {
// construire le tableau des utilisateurs à mettre à jour, indexé sur le login
$tableau_maj_auteurs = array_diff_key($tableau_csv_total, $tableau_nouveaux_auteurs);
// construire le tableau de correspondance login csv => id_auteur bdd
$tableau_maj_auteurs_id = array();
$Tlogins = array_keys($tableau_maj_auteurs);
$chaine_in = implode('","', $Tlogins);
$chaine_in = '"' . $chaine_in . '"';
$res = sql_select('id_auteur, login', 'spip_auteurs', array('login IN (' . $chaine_in . ')'));
while ($row = sql_fetch($res)) {
$tableau_maj_auteurs_id[$row['login']] = $row['id_auteur'];
}
// si remplacer les données zones et rubriques administrées: supprimer les liens existant
if ($type_maj == 'remplacer' and test_plugin_actif("accesrestreint")) {
// suppression des liens des rubriques administrées
objet_dissocier(array("auteur" => array_values($tableau_maj_auteurs_id)), array("rubrique" => "*"));
// suppression des zones des auteurs
zone_lier('', "auteur", array_values($tableau_maj_auteurs_id), 'del');
}
//spip_log("table zone admin","csvspip");
//spip_log($tableau_bdd_zones_admins,"csvspip");
// maj des données des auteurs
foreach ($tableau_maj_auteurs as $login => $Tauteur) {
csv2auteurs_ajout_utilisateur($login, $Tauteur, $Tnom_champs_bdd, $Tcorrespondances, $tableau_bdd_rubriques_admins, $tableau_bdd_zones_admins, $tableau_maj_auteurs_id[$login]);
}
/*
echo '<br><pre>';
var_dump($tableau_maj_auteurs_id);
*/
}
// dans tous les cas ajout des nouveaux
foreach ($tableau_nouveaux_auteurs as $login => $Tauteur) {
csv2auteurs_ajout_utilisateur($login, $Tauteur, $Tnom_champs_bdd, $Tcorrespondances, $tableau_bdd_rubriques_admins, $tableau_bdd_zones_admins);
}
// PARTIE II : Suppressions des absents (changer le statut des auteurs en 5.poubelle) avec 3 choix pour la gestion des articles associés
// 1. ras
// 2. supprimer les articles
// 3. transferer les articles dans une rubrique d'archivage
// Si choix3 : transferer les articles , création de la rubrique d'archive (en tenant compte d'une rubrique parent)
if ($traitement_article_efface == "transferer_articles") {
if (!($id_rubrique_archive = sql_fetsel('id_rubrique', 'spip_rubriques', array('titre ="' . $nom_rubrique_archive . '"', "id_parent={$id_rubrique_parent_archive}")))) {
$objet = 'rubrique';
$set = array('titre' => $nom_rubrique_archive);
$id_rubrique_archive = objet_inserer($objet, $id_rubrique_parent_archive);
objet_modifier($objet, $id_rubrique_archive, $set);
}
}
// si l'option auteurs sans articles = suppression complète
// alors on supprime aussi tous les auteurs à la poubelle (sans articles)
if ($abs_poubelle == 'supprimer') {
// récupérer les auteurs à la poubelle avec articles
$not_in = sql_allfetsel('auteurs.id_auteur', array('spip_auteurs_liens AS liens', 'spip_auteurs AS auteurs'), array('liens.id_auteur = auteurs.id_auteur', 'liens.objet="article"', 'auteurs.statut="5poubelle"'), array('liens.id_auteur'));
$Tnot_in = array();
foreach ($not_in as $index => $Tid_auteur) {
$Tnot_in[] = $Tid_auteur['id_auteur'];
}
$not_in = sql_in('id_auteur', $Tnot_in, 'NOT');
// récupérer les auteurs à la poubelle sans articles
$Tabs_poubelle = sql_allfetsel('id_auteur', 'spip_auteurs', array('statut="5poubelle"', $not_in));
$Ta_suppr = array();
foreach ($Tabs_poubelle as $index => $Tid_auteur) {
$Ta_suppr[] = $Tid_auteur['id_auteur'];
}
// effacer définitevement ces auteurs
$in = sql_in('id_auteur', $Ta_suppr);
sql_delete('spip_auteurs', $in);
}
// $Tid_poubelle = csv2auteurs_diff_absents($poubelle_bdd);
// csv2auteurs_supprimer_auteurs($Tid_poubelle, '5poubelle', $traitement_article_efface,$id_rubrique_parent_archive);
if ($abs_visiteurs) {
$Tid_visiteurs = csv2auteurs_diff_absents($visiteur_bdd, $tableau_csv_visiteurs);
csv2auteurs_supprimer_auteurs($Tid_visiteurs, '6forum', $traitement_article_efface, $id_rubrique_parent_archive);
}
if ($abs_redacs) {
$Tid_redacs = csv2auteurs_diff_absents($redacteur_bdd, $tableau_csv_redacs);
csv2auteurs_supprimer_auteurs($Tid_redacs, '1comite', $traitement_article_efface, $id_rubrique_parent_archive);
}
if ($abs_admins) {
$Tid_admins = csv2auteurs_diff_absents($admin_restreint_bdd, $tableau_csv_admins);
csv2auteurs_supprimer_auteurs($Tid_admins, '0minirezo', $traitement_article_efface, $id_rubrique_parent_archive);
}
// PARTIE III : maj des existants
// 1. ras
// 2. supprimer les articles
// 3. transferer les articles dans une rubrique d'archivage
/*
echo '<pre>$visiteur_bdd';
var_dump($visiteur_bdd);
echo '<br>$redacteur_bdd:';
var_dump($redacteur_bdd);
echo '<br>$admin_restreint';
var_dump($admin_restreint);
echo '</pre>';
die;
*/
// $retour['redirect'] = 'index.php?exec=csv2auteurs';
return $retour;
}
function maj_1_938()
{
$res = sql_select('extension', 'spip_documents', "extension='' OR extension is NULL");
if ($n = sql_count($res)) {
$repli = false;
// verifier que la colonne id_type est toujours la (update post 1.938)
$desc = sql_showtable('spip_documents');
if (!$desc or !isset($desc['field']['id_type'])) {
$repli = true;
}
$s = sql_select('extension' . ($repli ? '' : ',id_type'), 'spip_types_documents');
while ($t = sql_fetch($s)) {
if (isset($t['id_type'])) {
spip_query("UPDATE spip_documents\tSET `extension`=" . _q($t['extension']) . " WHERE `id_type`=" . _q($t['id_type']));
} else {
spip_query("UPDATE spip_documents\tSET `extension`=" . _q($t['extension']) . " WHERE fichier LIKE " . _q("%." . $t['extension']));
}
}
$res = sql_select('extension', 'spip_documents', "extension='' OR extension is NULL");
if ($n = sql_count($res)) {
spip_log("Table spip_documents : Colonne extension incomplete : {$n} lignes vides");
}
}
}
function import_tables($request, $archive) {
global $import_ok, $abs_pos, $affiche_progression_pourcent;
// regarder si on est pas en train d'importer dans une copie des tables
if (isset($GLOBALS['meta']['restauration_table_prefix'])) {
$charger = charger_fonction('charger','maj/vieille_base');
$charger($GLOBALS['meta']['vieille_version_installee']);
$GLOBALS['serveur_vieille_base'] = 0;
$prefix = $GLOBALS['connexions'][$GLOBALS['serveur_vieille_base']]['prefixe'];
$GLOBALS['connexions'][$GLOBALS['serveur_vieille_base']]['prefixe'] = $GLOBALS['meta']['restauration_table_prefix'];
// verifier qu'une table meta existe bien
// sinon c'est une restauration anterieure echouee
if (!sql_getfetsel('valeur','spip_meta','','','','0,1')){
$GLOBALS['connexions'][$GLOBALS['serveur_vieille_base']]['prefixe'] = $prefix;
return;
}
// recharger les metas
lire_metas();
}
$abs_pos = (!isset($GLOBALS['meta']["restauration_status"])) ? 0 :
$GLOBALS['meta']["restauration_status"];
// au premier appel destruction des tables a restaurer
// ou initialisation de la table des translations,
// mais pas lors d'une reprise.
if ($request['insertion']=='on') {
include_spip('inc/import_insere');
$request['init'] = (!$abs_pos) ? 'insere_1_init' : 'insere_1bis_init';
$request['boucle'] = 'import_insere';
} elseif ($request['insertion']=='passe2') {
$request['init'] = 'insere_2_init';
$request['boucle'] = 'import_translate';
} else {
$request['init'] = (!$abs_pos) ? 'import_init_tables' : 'import_table_choix';
$request['boucle'] = 'import_replace';
}
if (strncmp(".gz", substr($archive,-3),3)==0) {
$size = false;
$taille = taille_en_octets($abs_pos);
$file = gzopen($archive, 'rb');
$gz = 'gzread';
} else {
$size = @filesize($archive);
$taille = @floor(100 * $abs_pos / $size)." %";
$file = fopen($archive, 'rb');
$gz = 'fread';
}
if ($abs_pos==0) {
list($tag, $atts, $charset) = import_debut($file, $gz);
// improbable: fichier correct avant debut_admin et plus apres
if (!$tag) return !($import_ok = true);
$version_archive = import_init_meta($tag, $atts, $charset, $request);
} else {
$version_archive = $GLOBALS['meta']['restauration_version_archive'];
$atts = unserialize($GLOBALS['meta']['restauration_attributs_archive']);
spip_log("Reprise de l'importation interrompue en $abs_pos");
$_fseek = ($gz=='gzread') ? 'gzseek' : 'fseek';
$_fseek($file, $abs_pos);
}
// placer la connexion sql dans le bon charset
if (isset($GLOBALS['meta']['restauration_charset_sql_connexion']))
sql_set_charset($GLOBALS['meta']['restauration_charset_sql_connexion']);
if (!defined('_DEBUG_IMPORT')) define('_DEBUG_IMPORT', false);
if (_DEBUG_IMPORT)
ecrire_fichier(_DIR_TMP."debug_import.log","#####".date('Y-m-d H:i:s')."\n",false,false);
$fimport = import_charge_version($version_archive);
if ($request['insertion'] !== 'passe2')
import_affiche_javascript($taille);
if (function_exists('ob_flush')) @ob_flush();
flush();
$oldtable ='';
$cpt = 0;
$pos = $abs_pos;
// BOUCLE principale qui tourne en rond jusqu'a le fin du fichier
while ($table = $fimport($file, $request, $gz, $atts)) {
// memoriser pour pouvoir reprendre en cas d'interrupt,
// mais pas d'ecriture sur fichier, ca ralentit trop
ecrire_meta("restauration_status", "$abs_pos",'non');
if ($oldtable != $table) {
if (_DEBUG_IMPORT){
ecrire_fichier(_DIR_TMP."debug_import.log","----\n".$GLOBALS['debug_import_avant']."\n<<<<\n$table\n>>>>\n".$GLOBALS['debug_import_apres']."\n----\n",false,false);
}
if ($oldtable) spip_log("$cpt entrees","import");
spip_log("Analyse de $table (commence en $pos)","import");
affiche_progression_javascript($abs_pos,$size,$table);
$oldtable = $table;
$cpt = 0;
$pos = $abs_pos;
}
$cpt++;
}
spip_log("$cpt entrees","import");
spip_log("fin de l'archive, statut: " .($import_ok ? 'ok' : 'alert'),"import");
if (!$import_ok)
return _T('avis_archive_invalide') . ' ' .
_T('taille_octets', array('taille' => $pos)) ;
if ($GLOBALS['spip_version_base'] != (str_replace(',','.',$GLOBALS['meta']['version_installee']))){
// il FAUT recharger les bonnes desc serial/aux avant ...
include_spip('base/serial');
$GLOBALS['tables_principales']=array();
base_serial($GLOBALS['tables_principales']);
include_spip('base/auxiliaires');
$GLOBALS['tables_auxiliaires']=array();
base_auxiliaires($GLOBALS['tables_auxiliaires']);
$GLOBALS['tables_jointures']=array();
include_spip('public/interfaces');
declarer_interfaces();
include_spip('base/upgrade');
maj_base(); // upgrade jusqu'a la version courante
}
// regarder si on est pas en train d'importer dans une copie des tables
if (isset($GLOBALS['meta']['restauration_table_prefix_source'])){
$prefixe_source = $GLOBALS['meta']['restauration_table_prefix_source'];
$GLOBALS['connexions']['-1'] = $GLOBALS['connexions'][0];
// rebasculer le serveur sur les bonnes tables pour finir proprement
$GLOBALS['connexions'][0]['prefixe'] = $prefixe_source;
// et relire les meta de la bonne base
lire_metas();
$tables_recopiees = isset($GLOBALS['meta']['restauration_recopie_tables'])?unserialize($GLOBALS['meta']['restauration_recopie_tables']):array();
spip_log("charge tables_recopiees ".serialize($tables_recopiees),'dbdump');
// recopier les tables l'une sur l'autre
// il FAUT recharger les bonnes desc serial/aux avant ...
include_spip('base/serial');
$GLOBALS['tables_principales']=array();
base_serial($GLOBALS['tables_principales']);
include_spip('base/auxiliaires');
$GLOBALS['tables_auxiliaires']=array();
base_auxiliaires($GLOBALS['tables_auxiliaires']);
$GLOBALS['tables_jointures']=array();
include_spip('public/interfaces');
declarer_interfaces();
// puis relister les tables a importer
// et les vider si besoin, au moment du premier passage ici
// (et seulement si ce n'est pas une fusion, comment le dit-on ?)
$initialisation_copie = (!isset($GLOBALS['meta']["restauration_status_copie"])) ? 0 :
$GLOBALS['meta']["restauration_status_copie"];
if (!$initialisation_copie) {
// vide les tables qui le necessitent
$tables = import_init_tables($request);
ecrire_meta("restauration_status_copie", "ok",'non');
}
else
// la liste des tables a recopier
$tables = import_table_choix($request);
# var_dump($tables);die();
spip_log("tables a copier :".implode(", ",$tables),'dbdump');
if (in_array('spip_auteurs',$tables)){
$tables = array_diff($tables,array('spip_auteurs'));
$tables[] = 'spip_auteurs';
}
if (in_array('spip_meta',$tables)){
$tables = array_diff($tables,array('spip_meta'));
$tables[] = 'spip_meta';
}
sql_drop_table('spip_test','','-1');
foreach ($tables as $table){
if (sql_showtable($table,true,-1)){
if (!isset($tables_recopiees[$table])) $tables_recopiees[$table] = 0;
if ($tables_recopiees[$table]!==-1){
affiche_progression_javascript(0,0,$table);
while (true) {
$n = intval($tables_recopiees[$table]);
$res = sql_select('*',$table,'','','',"$n,400",'','-1');
while ($row = sql_fetch($res,'-1')){
array_walk($row,'sql_quote');
sql_replace($table,$row);
$tables_recopiees[$table]++;
}
if ($n == $tables_recopiees[$table])
break;
spip_log("recopie $table ".$tables_recopiees[$table],'dbdump');
affiche_progression_javascript($tables_recopiees[$table],0,$table);
ecrire_meta('restauration_recopie_tables',serialize($tables_recopiees));
}
sql_drop_table($table,'','-1');
spip_log("drop $table",'dbdump');
$tables_recopiees[$table]=-1;
ecrire_meta('restauration_recopie_tables',serialize($tables_recopiees));
spip_log("tables_recopiees ".serialize($tables_recopiees),'dbdump');
}
}
}
}
// recharger les metas
lire_metas();
#die();
return '' ;
}
/**
* Crée une vue SQL nommée `$nom`
*
* @param string $nom
* Nom de la vue à creer
* @param string $query_select
* Texte de la requête de sélection servant de base à la vue
* @param string $serveur
* Nom du connecteur
* @param bool $requeter
* Effectuer la requete, sinon la retourner
* @return bool|string
* - true si la vue est créée
* - false si erreur ou si la vue existe déja
* - string texte de la requête si $requeter vaut false
*/
function spip_mysql_create_view($nom, $query_select, $serveur = '', $requeter = true)
{
if (!$query_select) {
return false;
}
// vue deja presente
if (sql_showtable($nom, false, $serveur)) {
spip_log("Echec creation d'une vue sql ({$nom}) car celle-ci existe deja (serveur:{$serveur})", _LOG_ERREUR);
return false;
}
$query = "CREATE VIEW {$nom} AS " . $query_select;
return spip_mysql_query($query, $serveur, $requeter);
}
/**
* Marquer la procédure de dump comme finie
*
* @param string $status_file
* Fichier qui mémorise les infos utiles concernant la sauvegarde en cours
* @param string $action
* Type d'action supplémentaire à réaliser :
*
* - restaurer : supprimer la structure qui était stockée dans le dump
* - 'auvegarder : stocker dans le dump la structure de la base source
*/
function dump_end($status_file, $action = '')
{
$status_file = _DIR_TMP . basename($status_file) . ".txt";
if (!lire_fichier($status_file, $status) or !($status = unserialize($status))) {
return;
}
switch ($action) {
case 'restaurer':
// supprimer la structure qui etait stockee dans le dump
sql_delete('spip_meta', "nom='dump_structure_temp'");
break;
case 'sauvegarder':
// stocker dans le dump la structure de la base source
$structure = array();
foreach ($status['tables_copiees'] as $t => $n) {
$structure[$t] = sql_showtable($t, true);
}
dump_serveur($status['connect']);
spip_connect('dump');
// si spip_meta n'a pas ete backup elle n'est pas dans le dump, il faut la creer pour y stocker cette meta
if (!sql_showtable("spip_meta", true, "dump")) {
$desc = sql_showtable("spip_meta", true);
sql_create("spip_meta", $desc['field'], $desc['key'], false, false, "dump");
}
sql_delete('spip_meta', "nom='dump_structure_temp'", 'dump');
#enlever une vieille structure deja la, au cas ou
sql_insertq('spip_meta', array('nom' => 'dump_structure_temp', 'valeur' => serialize($structure), 'impt' => 'non'), array(), 'dump');
break;
}
$status['etape'] = 'fini';
ecrire_fichier($status_file, serialize($status));
}
### creation de la colonne cfg si absente ###
// creation de la colonne 'cfg' sur spip_auteurs si elle n'existe pas.
include_spip('base/abstract_sql');
$t = sql_showtable('spip_auteurs');
if (!isset($t['field']['cfg'])) {
sql_alter('TABLE spip_auteurs ADD COLUMN cfg TEXT DEFAULT \'\' NOT NULL');
}
### creation de la colonne 'extra' si absente ###
// creation de la colonne 'cfg' sur spip_auteurs si elle n'existe pas.
include_spip('base/abstract_sql');
$t = sql_showtable('spip_rubriques');
if (!isset($t['field']['extra'])) {
sql_alter('TABLE spip_rubriques ADD COLUMN extra TEXT DEFAULT \'\' NOT NULL');
}
### ecrire_config ###
// les bases de test
$assoc = array(
'one' => 'element 1',
'two' => 'element 2',
'three' => array('un'=>1, 'deux'=>2, 'troisc'=>"3")
);
$serassoc = serialize($assoc);
function verifier_colonne($creer = false)
{
$col = sql_showtable($table = $this->param->table);
if (!array_key_exists($colonne = $this->param->colonne, $col['field'])) {
if (!$creer) {
return false;
}
if (!sql_alter("TABLE " . $table . " ADD " . $colonne . " TEXT DEFAULT ''")) {
spip_log("CFG (ecrire_config) n'a pas reussi a creer automatiquement la colonne " . $colonne . " dans la table " . $table . ".");
return false;
}
spip_log("CFG (ecrire_config) a cree automatiquement la colonne " . $colonne . " dans la table " . $table . ".");
}
return true;
}
function base_trouver_table_dist($nom, $serveur=''){
static $nom_cache_desc_sql=array();
global $tables_principales, $tables_auxiliaires, $table_des_tables;
if (!spip_connect($serveur)
OR !preg_match('/^[a-zA-Z0-9._-]*/',$nom))
return null;
$connexion = &$GLOBALS['connexions'][$serveur ? strtolower($serveur) : 0];
// le nom du cache depend du serveur mais aussi du nom de la db et du prefixe
// ce qui permet une auto invalidation en cas de modif manuelle du fichier
// de connexion, et tout risque d'ambiguite
if (!isset($nom_cache_desc_sql[$serveur]))
$nom_cache_desc_sql[$serveur] =
_DIR_CACHE . 'sql_desc_'
. ($serveur ? "$serveur_":"")
. substr(md5($connexion['db'].":".$connexion['prefixe']),0,8)
.'.txt';
// un appel avec $nom vide est une demande explicite de vidange du cache des descriptions
if (!$nom){
spip_unlink($nom_cache_desc_sql[$serveur]);
$connexion['tables'] = array();
return null;
}
$nom_sql = $nom;
if (preg_match('/\.(.*)$/', $nom, $s))
$nom_sql = $s[1];
else
$nom_sql = $nom;
$desc = '';
// base sous SPIP: gerer les abreviations explicites des noms de table
if ($connexion['spip_connect_version']) {
include_spip('public/interfaces');
if (isset($table_des_tables[$nom])) {
$nom = $table_des_tables[$nom];
$nom_sql = 'spip_' . $nom;
}
}
// si c'est la premiere table qu'on cherche
// et si on est pas explicitement en recalcul
// on essaye de recharger le cache des decriptions de ce serveur
// dans le fichier cache
if (!isset($connexion['tables'][$nom])
AND $GLOBALS['var_mode']!=='recalcul'
AND (!isset($connexion['tables']) OR !$connexion['tables'])) {
if (lire_fichier($nom_cache_desc_sql[$serveur],$desc_cache)
AND $desc_cache=unserialize($desc_cache))
$connexion['tables'] = $desc_cache;
}
if (!isset($connexion['tables'][$nom])) {
include_spip('base/serial');
if (isset($tables_principales[$nom_sql]))
$fdesc = $tables_principales[$nom_sql];
// meme si pas d'abreviation declaree, trouver la table spip_$nom
// si c'est une table principale,
// puisqu'on le fait aussi pour les tables auxiliaires
elseif ($nom_sql==$nom AND isset($tables_principales['spip_' .$nom])){
$nom_sql = 'spip_' . $nom;
$fdesc = &$tables_principales[$nom_sql];
}
else {
include_spip('base/auxiliaires');
if (isset($tables_auxiliaires['spip_' .$nom])) {
$nom_sql = 'spip_' . $nom;
$fdesc = &$tables_auxiliaires[$nom_sql];
} else { # table locale a cote de SPIP, comme non SPIP:
$fdesc = array();
}
}
// faut il interpreter le prefixe 'spip_' ?
$transposer_spip = ($nom_sql != $nom);
// La *vraie* base a la priorite
if (true /* !$bdesc OR !$bdesc['field'] */) {
$desc = sql_showtable($nom_sql, $transposer_spip, $serveur);
if (!$desc OR !$desc['field']) {
if (!$fdesc) {
spip_log("trouver_table: table inconnue '$serveur' '$nom'");
return null;
}
// on ne sait pas lire la structure de la table :
// on retombe sur la description donnee dans les fichiers spip
$desc = $fdesc;
}
}
// S'il n'y a pas de key (cas d'une VIEW),
// on va inventer une PRIMARY KEY en prenant le premier champ
// de la table
if (!$desc['key']){
$p = array_keys($desc['field']);
$desc['key']['PRIMARY KEY'] = array_shift($p);
}
$desc['table']= $nom_sql;
$desc['connexion']= $serveur;
// objet_type peut provoquer un appel reentrant ici.
// pour ne pas faire de boucle infinie, on stocke ce qu'on a deja trouve
$connexion['tables'][$nom] = $desc;
$table = table_objet(objet_type($nom));
$desc['titre'] = isset($GLOBALS['table_titre'][$table])
? $GLOBALS['table_titre'][$table]
: (isset($desc['field']['titre']) ? 'titre' : '');
$connexion['tables'][$nom] = $desc;
// une nouvelle table a ete decrite
// mettons donc a jour le cache des descriptions de ce serveur
if (is_writeable(_DIR_CACHE))
ecrire_fichier($nom_cache_desc_sql[$serveur],serialize($connexion['tables']));
}
$connexion['tables'][$nom]['id_table']=$nom;
return $connexion['tables'][$nom];
}
function _sqlite_modifier_table($table, $colonne, $opt=array(), $serveur=''){
if (is_array($table)) {
reset($table);
list($table_origine,$table_destination) = each($table);
} else {
$table_origine = $table_destination = $table;
}
// ne prend actuellement qu'un changement
// mais pourra etre adapte pour changer plus qu'une colonne a la fois
if (is_array($colonne)) {
reset($colonne);
list($colonne_origine,$colonne_destination) = each($colonne);
} else {
$colonne_origine = $colonne_destination = $colonne;
}
if (!isset($opt['field'])) $opt['field'] = array();
if (!isset($opt['key'])) $opt['key'] = array();
// si les noms de tables sont differents, pas besoin de table temporaire
// on prendra directement le nom de la future table
$meme_table = ($table_origine == $table_destination);
$def_origine = sql_showtable($table_origine, false, $serveur);
$table_tmp = $table_origine . '_tmp';
// 1) creer une table temporaire avec les modifications
// - DROP : suppression de la colonne
// - CHANGE : modification de la colonne
// (foreach pour conserver l'ordre des champs)
// field
$fields = array();
// pour le INSERT INTO plus loin
// stocker la correspondance nouvelles->anciennes colonnes
$fields_correspondances = array();
foreach ($def_origine['field'] as $c=>$d){
if ($colonne_origine && ($c == $colonne_origine)) {
// si pas DROP
if ($colonne_destination){
$fields[$colonne_destination] = $opt['field'][$colonne_destination];
$fields_correspondances[$colonne_destination] = $c;
}
} else {
$fields[$c] = $d;
$fields_correspondances[$c] = $c;
}
}
// cas de ADD sqlite2 (ajout du champ en fin de table):
if (!$colonne_origine && $colonne_destination){
$fields[$colonne_destination] = $opt['field'][$colonne_destination];
}
// key...
$keys = array();
foreach ($def_origine['key'] as $c=>$d){
$c = str_replace($colonne_origine,$colonne_destination,$c);
$d = str_replace($colonne_origine,$colonne_destination,$d);
// seulement si on ne supprime pas la colonne !
if ($d)
$keys[$c] = $d;
}
// autres keys, on merge
$keys = array_merge($keys,$opt['key']);
$queries = array();
$queries[] = 'BEGIN TRANSACTION';
// copier dans destination (si differente de origine), sinon tmp
$table_copie = ($meme_table) ? $table_tmp : $table_destination;
if ($q = _sqlite_requete_create(
$table_copie,
$fields,
$keys,
$autoinc=false,
$temporary=false,
$ifnotexists=true,
$serveur)){
$queries[] = $q;
}
// 2) y copier les champs qui vont bien
$champs_dest = join(', ', array_keys($fields_correspondances));
$champs_ori = join(', ', $fields_correspondances);
$queries[] = "INSERT INTO $table_copie ($champs_dest) SELECT $champs_ori FROM $table_origine";
// 3) supprimer la table d'origine
$queries[] = "DROP TABLE $table_origine";
// 4) renommer la table temporaire
// avec le nom de la table destination
// si necessaire
if ($meme_table){
if (_sqlite_is_version(3, '', $serveur)){
$queries[] = "ALTER TABLE $table_copie RENAME TO $table_destination";
} else {
$queries[] = _sqlite_requete_create(
$table_destination,
$fields,
$keys,
$autoinc=false,
$temporary=false,
$ifnotexists=false, // la table existe puisqu'on est dans une transaction
$serveur);
$queries[] = "INSERT INTO $table_destination SELECT * FROM $table_copie";
$queries[] = "DROP TABLE $table_copie";
}
}
// 5) remettre les index !
foreach ($keys as $k=>$v) {
if ($k=='PRIMARY KEY'){}
else {
// enlever KEY
$k = substr($k,4);
$queries[] = "CREATE INDEX $table_destination"."_$k ON $table_destination ($v)";
}
}
$queries[] = "COMMIT";
// il faut les faire une par une car $query = join('; ', $queries).";"; ne fonctionne pas
foreach ($queries as $q){
$req = new sqlite_traiter_requete($q, $serveur);
if (!$req->executer_requete()){
spip_log("SQLite : ALTER TABLE table :"
." Erreur a l'execution de la requete : $q",'sqlite');
return false;
}
}
return true;
}
