PDO MySQL sauvegardes fonction

Que le script de sauvegarde est ridicule et nul ne devrait faire une autre version. J'ai vu que le script avant de l', ainsi que des tentatives similaires, et ils ont beaucoup de problèmes:

• Ne pas délimiter les noms de table dans l'arrière-tiques
• Ne gère pas les valeurs Null
• Ne gère pas les jeux de caractères
• Ne gère pas les données binaires
• N'est pas sauvegarder des Vues
• N'est pas sauvegarder des Déclencheurs ou des Procédures STOCKÉES ou des Fonctions STOCKÉES ou des Événements
• Utilise obsolète de l'extension mysql (mais c'est pourquoi vous voulez un AOP version, n'est-ce pas?)
• Utilise addslashes() à la place d'une bonne MySQL échapper la fonction.
• Ajoute tous de données pour tous tables dans une très longue chaîne, avant de sortir l'ensemble du contenu. Cela signifie que vous devez être en mesure de stocker l'ensemble de votre base de données dans une chaîne de caractères, qui sera presque certainement souffler votre PHP max limite de mémoire.

Voir aussi ma dernière réponse sur le malheureux David Walsh script de sauvegarde:

• Pourquoi mon script de sauvegarde de la base de données ne fonctionne pas en php?

---

Re votre commentaire:

Lire les commentaires sur la page du lien. Beaucoup de gens ont identifié des problèmes, et certains ont des solutions ou au moins des suggestions.

Le fait que ce script ajoute le tout dans une chaîne de caractères est un deal-breaker, je pense, mais il ne devrait pas être difficile de modifier le script pour ouvrir le fichier de sortie première, puis la sortie de chaque ligne de données au cours de la boucle, puis fermez le fichier après la boucle. C'est un no-brainer, je ne sais pas pourquoi le script ne fait pas ça. Mais il est assez clair que le script n'a pas été testé très bien.

Mais de toute façon, je ne voudrais pas essayer de réinventer la roue. Mysqldump ou mydumper faire ce travail très bien. FWIW, vous n'avez pas à exécuter la commande mysqldump sur le même serveur sur lequel réside la base de données. Mysqldump prend en charge une option pour --host de sorte que vous pouvez exécuter la commande mysqldump n'importe où pour sauvegarder une base de données distante, aussi longtemps que les pare-feu ne bloque pas votre client de se connecter. Fondamentalement, si vous pouvez vous connecter en PHP, application à la base de données à partir d'un client de l'hôte, vous pouvez vous connecter mysqldump.

Si ce n'est vraiment pas une option, alors je voudrais utiliser le dump de la base de la fonctionnalité de phpmyadmin. Ce sont matures et bien testé et ils dump tout correctement. Voici un article qui explique comment utiliser la fonction de vidage:

http://www.techrepublic.com/blog/smb-technologist/import-and-export-databases-using-phpmyadmin/

---

[Copie de mes commentaires de votre réponse:]

C'est entrer dans l'examen du code, ce qui n'est pas le but de StackOverflow. Mais brièvement:

• pas d'un soutien adéquat pour les NULS (les convertir en ");
• pas toujours délimitation des noms de table;
• à l'aide de non-ANSI guillemets comme délimiteurs de chaînes;
• à l'aide de tampon de requêtes sur d'immenses tableaux de break PHP max limite de mémoire;
• ajoutant toutes les lignes d'une table immense, va briser PHP max limite de mémoire;
• à l'aide de addslashes() au lieu de PDO::quote();
• vérifier pour les erreurs de requête qu'à la fin de la fonction;
• pas de vérification de l'échec de création du fichier;
• gzip extension ne peuvent pas être chargés
• Aussi, probablement encore ne prend pas en charge les données UTF8.

mais c'est comment y arriver, non???

Oui, c'est mieux que l'originale de David Walsh script. 🙂

quoi de mal avec les valeurs Null "?

NULL n'est pas la même chose que " dans SQL (sauf dans Oracle, mais ils ne sont pas conformes avec la norme SQL dans ce cas). Voir MySQL, de mieux insérer la valeur NULL ou une chaîne vide?

tableau de la structure doit être très très grand max de la mémoire. chaque ligne d'insertion est écrit dans le fichier individuellement, donc encore une fois, la ligne doit être très très grand max de la mémoire.

J'ai mal lu le code sur la question limite de mémoire. Vous êtes à la rédaction de sortie pour chaque ligne, donc ce n'est pas grave (sauf si la ligne contient un 1 go de blob ou quelque chose).

Mais vous ne devriez pas sortie une seule instruction INSERT avec séparées par des virgules ensemble de lignes. Même mysqldump --extended-insert sorties d'une longueur finie de données, puis commence une nouvelle instruction INSERT. Le critère est de savoir si la longueur de l'instruction d'INSERTION s'inscrit dans l'argument d'option pour --net-buffer-length.

quoi avec de mal avec "" les délimiteurs de chaînes? comment puis-je obtenir de l'ANSI?

En ANSI SQL, des simples guillemets " sont utilisés pour délimiter les chaînes de caractères littérales ou la date de littéraux. Double-guillemets "" sont utilisés pour délimiter des identificateurs comme nom de table ou des noms de colonne. Par défaut, MySQL traite le même, mais c'est non-standard. Voir Faire de différentes bases de données utiliser différents nom de devis?. Si vous essayez d'importer vos données de sauvegarde sur un serveur MySQL où vous avez SET SQL_MODE=ANSI_QUOTES, l'importation échouera.

et que les tableaux ne sont pas délimités?

Exemple: query('SELECT * FROM '.$table); et en fait tous les autres cas où vous utilisez $table dans une requête. Vous ne délimité par la table une fois, dans l'instruction INSERT de votre script sorties.

$tous les tableaux ne sont pas délimités, ont-ils tous besoin d'être avec les " "?

MySQL considère toujours en arrière-tiques comme identifiant des séparateurs et des guillemets simples pour les chaînes de caractères, les dates. Mais les guillemets changent de signification selon le SQL_MODE je l'ai mentionné. Vous ne pouvez pas assumer qui SQL_MODE est en effet sur l'instance MySQL vous restaurer, il est donc préférable si vous utilisez l'arrière-tiques pour les identifiants, et des guillemets simples pour les chaînes de caractères. La raison pour laquelle vous pourriez délimiter comme vous interrogez votre table est que vous pourriez avoir une table des noms qui sont des mots réservés SQL, ou qui contiennent des caractères spéciaux, etc.

pouvez-vous insérer des chars sans délimiteurs dans mysql, ou au besoin de l' "? grâce

Vous pouvez insérer tous les types numériques sans délimiteurs. Seules des chaînes de caractères et les dates de besoin délimiteurs. Voir dev.mysql.com/doc/refman/5.6/en/literals.html

OriginalL'auteur Bill Karwin

Comme recommandé par https://stackoverflow.com/a/18281687/2259391 utilisation mysqldump avec exec. Il se résume à ceci:

<?php
function importDatabase($host, $user, $password, $database, $backupFilePath)
{
//returns true iff successfull
return exec('mysqlimport --host '. $host .' --user '. $user .' --password '. $password .' '. $database .' '.targetFilePath) === 0;
}
function exportDatabase($host, $user, $password, $database, $targetFilePath)
{
//returns true iff successfull
return exec('mysqldump --host '. $host .' --user '. $user .' --password '. $password .' '. $database .' --result-file='.targetFilePath) === 0;
}

OriginalL'auteur Florian Moser

function backupDB()
{
$db_config = getDbConfigFromWordPress();
if ($db_config === false) {
unset($db_config);
logMessage('Unable to get database configuration from WordPress', true, 'red');
return false;
}
$new_backup_file = __DIR__ . DIRECTORY_SEPARATOR . 'newbackup_xxx_date.sql';
if (is_file($new_backup_file) && is_writable($new_backup_file)) {
@unlink($new_backup_file);
} elseif (is_file($new_backup_file) && !is_writable($new_backup_file)) {
logMessage('Unable to remove new backup SQL file. This is necessary to create backup SQL file.', true, 'red');
return false;
}
unset($new_backup_file);
$dbh = new \PDO('mysql:dbname=' . $db_config['dbname'] . ';host=' . $db_config['dbhost'] . ';charset=' . $db_config['dbcharset'], $db_config['dbuser'], $db_config['dbpassword']);
$dbh->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
$dbh->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_OBJ);
$dbh->setAttribute(\PDO::ATTR_EMULATE_PREPARES, true);
$sth = $dbh->prepare('SHOW TABLES');
$sth->execute();
$result = $sth->fetchAll(\PDO::FETCH_COLUMN);
$tables = [];
if (is_array($result) && !empty($result)) {
foreach ($result as $row) {
if (is_string($row) && stristr($row, $db_config['tableprefix']) !== false) {
$tables[] = $row;
} elseif (is_array($row) && array_key_exists(0, $row) && stristr($row[0], $db_config['tableprefix']) !== false) {
$tables[] = $row[0];
}
}//endforeach;
natcasesort($tables);
}
$sth->closeCursor();
unset($result, $row, $sth);
//begins export string header.
$export_sql = '-- Manual backup SQL Dump'."\n\n";
$export_sql .= 'SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";'."\n\n\n";
$export_sql .= '--'."\n";
$export_sql .= '-- Database: `' . $db_config['dbname'] . '`'."\n";
$export_sql .= '--'."\n\n";
unset($db_config);
writeDownBackupDB($export_sql);
unset($export_sql);
//starting to loop thru tables.
if (isset($tables) && is_array($tables)) {
foreach ($tables as $table) {
$export_sql = '-- --------------------------------------------------------'."\n\n";
$export_sql .= '--'."\n";
$export_sql .= '-- Table structure for table `' . $table . '`'."\n";
$export_sql .= '--'."\n\n";
$export_sql .= 'DROP TABLE IF EXISTS `' . $table . '`;'."\n";
$sth = $dbh->prepare('SHOW CREATE TABLE `' . $table . '`');
$sth->execute();
$row = $sth->fetch(\PDO::FETCH_NUM);
if (isset($row[1])) {
$create_sql_string = $row[1];
$create_sql_string = str_replace(['CREATE TABLE `'], ['CREATE TABLE IF NOT EXISTS `'], $create_sql_string);
if (substr($create_sql_string, -1) != ';') {
$create_sql_string .= ' ;';
}
} else {
$create_sql_string = '';
}
unset($row);
$export_sql .= $create_sql_string."\n\n";
$sth->closeCursor();
unset($sth);
writeDownBackupDB($export_sql);
unset($export_sql);
$export_sql = '--'."\n";
$export_sql .= '-- Dumping data for table `' . $table . '`'."\n";
$export_sql .= '--'."\n\n";
writeDownBackupDB($export_sql);
unset($export_sql);
//get fields
$sth = $dbh->prepare('SELECT * FROM `' . $table . '` LIMIT 1');
$sth->execute();
$result = $sth->fetch(\PDO::FETCH_ASSOC);
if (is_array($result)) {
$fields = array_keys($result);
} else {
$fields = [];
}
$sth->closeCursor();
unset($result, $sth);
//get fields type
$sth = $dbh->prepare('DESCRIBE `' . $table . '`');
$sth->execute();
$table_columns = $sth->fetchAll();
$columns = [];
if (is_array($table_columns)) {
foreach ($table_columns as $column) {
$columns[$column->Field] = [
'field' => $column->Field,
'type' => $column->Type,
'null' => $column->Null,
'default' => $column->Default,
];
}//endforeach;
unset($column);
}
$sth->closeCursor();
unset($sth, $table_columns);
if (isset($fields) && is_array($fields) && !empty($fields)) {
$select_string = 'SELECT ';
$i_count_field = 1;
foreach ($fields as $field) {
$select_string .= 'IF (`' . $field . '` IS NULL, \'FIELD_VALUE_NULL\', `' . $field . '`) AS `' . $field . '`';
if ($i_count_field < count($fields)) {
$select_string .= ', ';
}
$i_count_field++;
}//endforeach;
unset($i_count_field, $field);
$select_string .= ' FROM `' . $table . '`';
$sth = $dbh->prepare($select_string);
unset($select_string);
$sth->execute();
$result = $sth->fetchAll();
$export_sql = '';
if (is_array($result) && !empty($result)) {
//generate INSERT INTO `table_name` string.
$export_sql .= 'INSERT INTO `' . $table . '` (';
$i_count = 1;
foreach ($fields as $field) {
$export_sql .= '`' . $field . '`';
if ($i_count < count($fields)) {
$export_sql .= ', ';
}
$i_count++;
}//endforeach;
unset($field, $i_count);
$export_sql .= ') VALUES'."\n";
writeDownBackupDB($export_sql);
unset($export_sql);
//generate VALUES of INSERT INTO.
if (is_array($result)) {
$i_count = 1;
$i_count_break = 1;
foreach ($result as $row) {
$export_sql = '(';
$i_count_fields = 1;
foreach ($fields as $field) {
$field_value = $row->{$field};
//escape slash
$field_value = str_replace('\\', '\\\\', $field_value);
//sanitize new line
$field_value = str_replace(["\r\n", "\r", "\n"], ['\r\n', '\r', '\n'], $field_value);
//escape single quote
$field_value = str_replace('\'', '\'\'', $field_value);
//change value to NULL if it is NULL.
if ($field_value === 'FIELD_VALUE_NULL') {
$field_value = 'NULL';
}
//detect field value type and cloak with single quote.
if (isset($columns[$field]['type']) && 
(
stristr($columns[$field]['type'], 'tinyint(') !== false ||
stristr($columns[$field]['type'], 'smallint(') !== false ||
stristr($columns[$field]['type'], 'mediumint(') !== false ||
stristr($columns[$field]['type'], 'int(') !== false ||
stristr($columns[$field]['type'], 'bigint(') !== false
)
) {
//this field column type is int
if (!is_numeric($field_value) && $field_value !== 'NULL') {
$field_value = '\'' . $field_value . '\'';
}
} else {
if ($field_value !== 'NULL') {
$field_value = '\'' . $field_value . '\'';
}
}
$export_sql .= $field_value;
unset($field_value);
if ($i_count_fields < count($fields)) {
$export_sql .= ', ';
}
$i_count_fields++;
}//endforeach;
unset($field, $i_count_fields);
$export_sql .= ')';
if ($i_count < count($result)) {
if ($i_count_break >= 30) {
$export_sql .= ';'."\n";
writeDownBackupDB($export_sql);
unset($export_sql);
$i_count_break = 0;
$export_sql = 'INSERT INTO `' . $table . '` (';
$i_count_fields = 1;
foreach ($fields as $field) {
$export_sql .= '`' . $field . '`';
if ($i_count_fields < count($fields)) {
$export_sql .= ', ';
}
$i_count_fields++;
}//endforeach;
unset($field, $i_count_fields);
$export_sql .= ') VALUES'."\n";
writeDownBackupDB($export_sql);
unset($export_sql);
$export_sql = '';
} else {
$export_sql .= ','."\n";
}
} else {
$export_sql .= ';'."\n\n";
}
$i_count++;
$i_count_break++;
writeDownBackupDB($export_sql);
unset($export_sql);
}//endforeach;
unset($i_count, $i_count_break, $result, $row);
}
} else {
$export_sql .= "\n";
writeDownBackupDB($export_sql);
unset($export_sql);
}
unset($fields);
$sth->closeCursor();
unset($result, $sth);
} else {
$export_sql = "\n";
writeDownBackupDB($export_sql);
unset($export_sql);
}
unset($export_sql);
}//endforeach;
unset($table);
}
unset($tables);
unset($dbh);
logMessage('Backup DB completed. Max memory usage is ' . formatBytes(memory_get_peak_usage(true)) . '.', true, 'green');
return true;
}//backupDB
/**
* Write content to backup SQL file by append.
* 
* @param string $content
*/
function writeDownBackupDB($content)
{
$new_backup_file = __DIR__ . DIRECTORY_SEPARATOR . 'newbackup_xxx_date.sql';
$handle = fopen($new_backup_file, 'a+');
fwrite($handle, $content);
fclose($handle);
unset($handle, $new_backup_file);
}//writeDownBackupDB
logMessage('Beginning backup DB.', true, 'light_gray');
backupDB();

Veuillez noter que...

1. Certaines fonctions sont manquantes comme logMessage(), getDbConfigFromWordPress(). Veuillez retirer de la avant de l'utiliser.
2. Quelque chose comme $db_config['tableprefix'] ou $db_config[...] doit être changé.
3. Il y a beaucoup de choses qui ne peuvent pas gérer comme @Bill Karwin dit.
4. Je ne suis pas sûr de soutien des données UTF-8, mais comme je vois qu'il est en charge de nombreuses langues et prennent également en charge des émoticônes ().
5. Exportation à l'aide de commande de mysql est toujours la meilleure idée.

OriginalL'auteur vee