J'ai reçu ce tutoriel sur Internet. Mais je n'ai même pas une compréhension de base sur la façon dont la sauvegarde d'une base de données MySQL à travers PHP fonctionnerait.Comment faire pour sauvegarder la base de données MySQL en PHP?
Using PHP to Backup MySQL Databases
Pouvez-vous recommander quelques sites que je peux utiliser comme référence pour que je puisse l'étudier?
Bien que vous puissiez exécuter des commandes de sauvegarde depuis PHP, elles n'ont rien à voir avec PHP. Tout est à propos de MySQL.
Je suggère d'utiliser l'utilitaire mysqldump pour sauvegarder votre base de données. La documentation peut être trouvée ici: http://dev.mysql.com/doc/refman/5.1/en/mysqldump.html.
L'utilisation de base de mysqldump est
mysqldump -u user_name -p name-of-database >file_to_write_to.sql
Vous pouvez ensuite restaurer la sauvegarde avec une commande comme
mysql -u user_name -p <file_to_read_from.sql
Avez-vous accès à cron? Je suggère de faire un script PHP qui exécute mysqldump comme un travail cron. Ce serait quelque chose comme
<?php
$filename='database_backup_'.date('G_a_m_d_y').'.sql';
$result=exec('mysqldump database_name --password=your_pass --user=root --single-transaction >/var/backups/'.$filename,$output);
if($output==''){/* no output is good */}
else {/* we have something to log the output here*/}
Si mysqldump n'est pas disponible, l'article décrit une autre méthode, en utilisant les commandes SELECT INTO OUTFILE et LOAD DATA INFILE. La seule connexion à PHP est que vous utilisez PHP pour vous connecter à la base de données et exécuter les commandes SQL. Vous pouvez également le faire à partir du programme MySQL en ligne de commande, le moniteur MySQL.
C'est assez simple, vous écrivez un fichier SQL avec une commande, et vous le chargez/l'exécutez quand il est temps de restaurer.
Vous pouvez trouver les documents pour sélectionner dans le fichier de sortie here (recherchez simplement la sortie de fichier). LOAD DATA INFILE est essentiellement l'inverse de cela. Voir here pour les docs.
Voici une pure classe PHP pour effectuer des sauvegardes sur les bases de données MySQL de ne pas l'aide des commandes de mysqldump ou mysql: Backing up MySQL databases with pure PHP
Si vous souhaitez sauvegarder une base de données à partir du script php, vous pouvez utiliser une classe par exemple Appelons il MySQL. Cette classe utilisera PDO (construit en classe php qui gérera la connexion à la base de données). Cette classe pourrait ressembler à ceci:
<?php /*defined in your exampleconfig.php*/
define('DBUSER','root');
define('DBPASS','');
define('SERVERHOST','localhost');
?>
<?php /*defined in examplemyclass.php*/
class MySql{
private $dbc;
private $user;
private $pass;
private $dbname;
private $host;
function __construct($host="localhost", $dbname="your_databse_name_here", $user="your_username", $pass="your_password"){
$this->user = $user;
$this->pass = $pass;
$this->dbname = $dbname;
$this->host = $host;
$opt = array(
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
);
try{
$this->dbc = new PDO('mysql:host='.$this->host.';dbname='.$this->dbname.';charset=utf8', $user, $pass, $opt);
}
catch(PDOException $e){
echo $e->getMessage();
echo "There was a problem with connection to db check credenctials";
}
} /*end function*/
public function backup_tables($tables = '*'){ /* backup the db OR just a table */
$host=$this->host;
$user=$this->user;
$pass=$this->pass;
$dbname=$this->dbname;
$data = "";
//get all of the tables
if($tables == '*')
{
$tables = array();
$result = $this->dbc->prepare('SHOW TABLES');
$result->execute();
while($row = $result->fetch(PDO::FETCH_NUM))
{
$tables[] = $row[0];
}
}
else
{
$tables = is_array($tables) ? $tables : explode(',',$tables);
}
//cycle through
foreach($tables as $table)
{
$resultcount = $this->dbc->prepare('SELECT count(*) FROM '.$table);
$resultcount->execute();
$num_fields = $resultcount->fetch(PDO::FETCH_NUM);
$num_fields = $num_fields[0];
$result = $this->dbc->prepare('SELECT * FROM '.$table);
$result->execute();
$data.= 'DROP TABLE '.$table.';';
$result2 = $this->dbc->prepare('SHOW CREATE TABLE '.$table);
$result2->execute();
$row2 = $result2->fetch(PDO::FETCH_NUM);
$data.= "\n\n".$row2[1].";\n\n";
for ($i = 0; $i < $num_fields; $i++)
{
while($row = $result->fetch(PDO::FETCH_NUM))
{
$data.= 'INSERT INTO '.$table.' VALUES(';
for($j=0; $j<$num_fields; $j++)
{
$row[$j] = addslashes($row[$j]);
$row[$j] = str_replace("\n","\\n",$row[$j]);
if (isset($row[$j])) { $data.= '"'.$row[$j].'"' ; } else { $data.= '""'; }
if ($j<($num_fields-1)) { $data.= ','; }
}
$data.= ");\n";
}
}
$data.="\n\n\n";
}
//save filename
$filename = 'db-backup-'.time().'-'.(implode(",",$tables)).'.sql';
$this->writeUTF8filename($filename,$data);
/*USE EXAMPLE
$connection = new MySql(SERVERHOST,"your_db_name",DBUSER, DBPASS);
$connection->backup_tables(); //OR backup_tables("posts");
$connection->closeConnection();
*/
} /*end function*/
private function writeUTF8filename($filenamename,$content){ /* save as utf8 encoding */
$f=fopen($filenamename,"w+");
# Now UTF-8 - Add byte order mark
fwrite($f, pack("CCC",0xef,0xbb,0xbf));
fwrite($f,$content);
fclose($f);
/*USE EXAMPLE this is only used by public function above...
$this->writeUTF8filename($filename,$data);
*/
} /*end function*/
public function recoverDB($file_to_load){
echo "write some code to load and proccedd .sql file in here ...";
/*USE EXAMPLE this is only used by public function above...
recoverDB("some_buck_up_file.sql");
*/
} /*end function*/
public function closeConnection(){
$this->dbc = null;
//EXAMPLE OF USE
/*$connection->closeConnection();*/
}/*end function*/
} /*END OF CLASS*/
?>
Maintenant, vous pouvez simplement utiliser dans votre backup.php:
include ('config.php');
include ('myclass.php');
$connection = new MySql(SERVERHOST,"your_databse_name_here",DBUSER, DBPASS);
$connection->backup_tables(); /*Save all tables and it values in selected database*/
$connection->backup_tables("post_table"); /*Saves only table name posts_table from selected database*/
$connection->closeConnection();
Ce qui signifie que la visite cette page entraînera la sauvegarde de votre fichier ... de Bien sûr, il ne doit pas être de cette façon :) vous pouvez appeler cette méthode sur chaque poste de votre base de données pour être à jour tout le temps, cependant, je recommanderais de l'écrire dans un fichier tout le temps au lieu de créer nouveaux fichiers avec time() ... comme ci-dessus.
Espérons que ça aide et bonne chance!:>
exemple:
EXPORT_TABLES("localhost","user","pass","db_name");
Code:
<?php
// https://github.com/tazotodua/useful-php-scripts
//optional: 5th parameter - backup specific tables only: array("mytable1","mytable2",...)
//optional: 6th parameter - backup filename
// NOTE! to adequatelly replace strings in DB, MUST READ: goo.gl/nCwWsS
function EXPORT_TABLES($host,$user,$pass,$name, $tables=false, $backup_name=false){
set_time_limit(3000); $mysqli = new mysqli($host,$user,$pass,$name); $mysqli->select_db($name); $mysqli->query("SET NAMES 'utf8'");
$queryTables = $mysqli->query('SHOW TABLES'); while($row = $queryTables->fetch_row()) { $target_tables[] = $row[0]; } if($tables !== false) { $target_tables = array_intersect($target_tables, $tables); }
$content = "SET SQL_MODE = \"NO_AUTO_VALUE_ON_ZERO\";\r\nSET time_zone = \"+00:00\";\r\n\r\n\r\n/*!40101 SET @[email protected]@CHARACTER_SET_CLIENT */;\r\n/*!40101 SET @[email protected]@CHARACTER_SET_RESULTS */;\r\n/*!40101 SET @[email protected]@COLLATION_CONNECTION */;\r\n/*!40101 SET NAMES utf8 */;\r\n--\r\n-- Database: `".$name."`\r\n--\r\n\r\n\r\n";
foreach($target_tables as $table){
if (empty($table)){ continue; }
$result = $mysqli->query('SELECT * FROM `'.$table.'`'); $fields_amount=$result->field_count; $rows_num=$mysqli->affected_rows; $res = $mysqli->query('SHOW CREATE TABLE '.$table); $TableMLine=$res->fetch_row();
$content .= "\n\n".$TableMLine[1].";\n\n";
for ($i = 0, $st_counter = 0; $i < $fields_amount; $i++, $st_counter=0) {
while($row = $result->fetch_row()) { //when started (and every after 100 command cycle):
if ($st_counter%100 == 0 || $st_counter == 0) {$content .= "\nINSERT INTO ".$table." VALUES";}
$content .= "\n("; for($j=0; $j<$fields_amount; $j++){ $row[$j] = str_replace("\n","\\n", addslashes($row[$j])); if (isset($row[$j])){$content .= '"'.$row[$j].'"' ;} else{$content .= '""';} if ($j<($fields_amount-1)){$content.= ',';} } $content .=")";
//every after 100 command cycle [or at last line] ....p.s. but should be inserted 1 cycle eariler
if ((($st_counter+1)%100==0 && $st_counter!=0) || $st_counter+1==$rows_num) {$content .= ";";} else {$content .= ",";} $st_counter=$st_counter+1;
}
} $content .="\n\n\n";
}
$content .= "\r\n\r\n/*!40101 SET [email protected]_CHARACTER_SET_CLIENT */;\r\n/*!40101 SET [email protected]_CHARACTER_SET_RESULTS */;\r\n/*!40101 SET [email protected]_COLLATION_CONNECTION */;";
$backup_name = $backup_name ? $backup_name : $name."___(".date('H-i-s')."_".date('d-m-Y').")__rand".rand(1,11111111).".sql";
ob_get_clean(); header('Content-Type: application/octet-stream'); header("Content-Transfer-Encoding: Binary"); header("Content-disposition: attachment; filename=\"".$backup_name."\"");
echo $content; exit;
} //see import.php too
?>
// mis à jour par @ conseiller de Mohammad.
Hey merci c'est utile mais si on ne veut pas l'insert et on n'a besoin que de structures de base de données? –
je l'ai fait moi-même je viens de commenter '' $ content. = "\ NINSERT INTO". $ Table. "VALEURS"; '' et il produit seulement la structure pas insérer des requêtes –
Voici le fichier php qui vous permettra de créer/télécharger votre sauvegarde de base de données de manière efficace Ce fichier unique avec fonctionnalité de sécurité sur la page. seulement vous devez télécharger ce fichier dans votre dossier public ou dossier de projet et l'appeler via le navigateur.
Télécharger URL- https://github.com/vkt005/php-mysql-db-backup
@tazo réponse de Todua ci-dessus
Bien que j'ai mis voté la réponse ci-dessus, puisqu'elle était la seule solution de travail avec la mise en œuvre de PHP « pur » qui n'a pas produit 0 fichiers de longueur, et les fichiers semblent bien au premier coup d'oeil, cependant, notez qu'il a échoué à certaines clés étrangères lorsque j'ai essayé d'importer ma base de données à partir du fichier de sauvegarde.
Les solutions basées sur mysqldump en PHP sont beaucoup plus sûres à utiliser.
solution pour prendre la sauvegarde de votre base de données dans « dbbackup » Dossier/Répertoire
<?php
error_reporting(E_ALL);
/* Define database parameters here */
define("DB_USER", 'root');
define("DB_PASSWORD", '');
define("DB_NAME", 'YOUR_DATABASE _NAME');
define("DB_HOST", 'localhost');
define("OUTPUT_DIR", 'dbBackup'); // Folder/Directory Name
define("TABLES", '*');
/* Instantiate Backup_Database and perform backup */
$backupDatabase = new Backup_Database(DB_HOST, DB_USER, DB_PASSWORD, DB_NAME);
$status = $backupDatabase->backupTables(TABLES, OUTPUT_DIR) ? 'OK' : 'KO';
echo "Backup result: " . $status . " - By Irshad Khan";
/* The Backup_Database class */
class Backup_Database {
/* Host where database is located */
var $host = 'localhost';
var $username = 'root';
var $passwd = '';
var $dbName = 'YOUR_DATABASE _NAME';
var $charset = '';
/* Constructor initializes database */
function Backup_Database($host, $username, $passwd, $dbName, $charset = 'utf8') {
$this->host = $host;
$this->username = $username;
$this->passwd = $passwd;
$this->dbName = $dbName;
$this->charset = $charset;
$this->initializeDatabase();
}
protected function initializeDatabase() {
$conn = @mysql_connect($this->host, $this->username, $this->passwd); // Ik Added @ to Hide PDO Error Message
mysql_select_db($this->dbName, $conn);
if (!mysql_set_charset($this->charset, $conn)) {
mysql_query('SET NAMES ' . $this->charset);
}
}
/* Backup the whole database or just some tables Use '*' for whole database or 'table1 table2 table3...' @param string $tables */
public function backupTables($tables = '*', $outputDir = '.') {
try {
/* Tables to export */
if ($tables == '*') {
$tables = array();
$result = mysql_query('SHOW TABLES');
while ($row = mysql_fetch_row($result)) {
$tables[] = $row[0];
}
} else {
$tables = is_array($tables) ? $tables : explode(',', $tables);
}
$sql = 'CREATE DATABASE IF NOT EXISTS ' . $this->dbName . ";\n\n";
$sql .= 'USE ' . $this->dbName . ";\n\n";
/* Iterate tables */
foreach ($tables as $table) {
echo "Backing up " . $table . " table...";
$result = mysql_query('SELECT * FROM ' . $table);
$numFields = mysql_num_fields($result);
$sql .= 'DROP TABLE IF EXISTS ' . $table . ';';
$row2 = mysql_fetch_row(mysql_query('SHOW CREATE TABLE ' . $table));
$sql.= "\n\n" . $row2[1] . ";\n\n";
for ($i = 0; $i < $numFields; $i++) {
while ($row = mysql_fetch_row($result)) {
$sql .= 'INSERT INTO ' . $table . ' VALUES(';
for ($j = 0; $j < $numFields; $j++) {
$row[$j] = addslashes($row[$j]);
// $row[$j] = ereg_replace("\n", "\\n", $row[$j]);
if (isset($row[$j])) {
$sql .= '"' . $row[$j] . '"';
} else {
$sql.= '""';
}
if ($j < ($numFields - 1)) {
$sql .= ',';
}
}
$sql.= ");\n";
}
}
$sql.="\n\n\n";
echo " OK <br/><br/>" . "";
}
} catch (Exception $e) {
var_dump($e->getMessage());
return false;
}
return $this->saveFile($sql, $outputDir);
}
/* Save SQL to file @param string $sql */
protected function saveFile(&$sql, $outputDir = '.') {
if (!$sql)
return false;
try {
$handle = fopen($outputDir . '/db-backup-' . $this->dbName . '-' . date("Ymd-His", time()) . '.sql', 'w+');
fwrite($handle, $sql);
fclose($handle);
} catch (Exception $e) {
var_dump($e->getMessage());
return false;
}
return true;
}
}
?>
Sur la base de la bonne solution fournie par tazo todua, j'ai fait quelques changements depuis mysql_connect a désapprouvée et pas pris en charge nouvelle version de php. Je l'ai utilisé à la place mysqli_connect et augmenté les performances d'insérer des valeurs à la base de données:
<?php
/**
* Updated: Mohammad M. AlBanna
* Website: MBanna.info
*/
//MySQL server and database
$dbhost = 'localhost';
$dbuser = 'my_user';
$dbpass = 'my_pwd';
$dbname = 'database_name';
$tables = '*';
//Call the core function
backup_tables($dbhost, $dbuser, $dbpass, $dbname, $tables);
//Core function
function backup_tables($host, $user, $pass, $dbname, $tables = '*') {
$link = mysqli_connect($host,$user,$pass, $dbname);
// Check connection
if (mysqli_connect_errno())
{
echo "Failed to connect to MySQL: " . mysqli_connect_error();
exit;
}
mysqli_query($link, "SET NAMES 'utf8'");
//get all of the tables
if($tables == '*')
{
$tables = array();
$result = mysqli_query($link, 'SHOW TABLES');
while($row = mysqli_fetch_row($result))
{
$tables[] = $row[0];
}
}
else
{
$tables = is_array($tables) ? $tables : explode(',',$tables);
}
$return = '';
//cycle through
foreach($tables as $table)
{
$result = mysqli_query($link, 'SELECT * FROM '.$table);
$num_fields = mysqli_num_fields($result);
$num_rows = mysqli_num_rows($result);
$return.= 'DROP TABLE IF EXISTS '.$table.';';
$row2 = mysqli_fetch_row(mysqli_query($link, 'SHOW CREATE TABLE '.$table));
$return.= "\n\n".$row2[1].";\n\n";
$counter = 1;
//Over tables
for ($i = 0; $i < $num_fields; $i++)
{ //Over rows
while($row = mysqli_fetch_row($result))
{
if($counter == 1){
$return.= 'INSERT INTO '.$table.' VALUES(';
} else{
$return.= '(';
}
//Over fields
for($j=0; $j<$num_fields; $j++)
{
$row[$j] = addslashes($row[$j]);
$row[$j] = str_replace("\n","\\n",$row[$j]);
if (isset($row[$j])) { $return.= '"'.$row[$j].'"' ; } else { $return.= '""'; }
if ($j<($num_fields-1)) { $return.= ','; }
}
if($num_rows == $counter){
$return.= ");\n";
} else{
$return.= "),\n";
}
++$counter;
}
}
$return.="\n\n\n";
}
//save file
$fileName = 'db-backup-'.time().'-'.(md5(implode(',',$tables))).'.sql';
$handle = fopen($fileName,'w+');
fwrite($handle,$return);
if(fclose($handle)){
echo "Done, the file name is: ".$fileName;
exit;
}
}
J'ai aussi eu une situation et je ne pouvions pas trouver un outil pour me satisfaire. Donc, par souci de sauvegarde/restauration des données mysql de PHP j'ai fait un programme qui peut compresser les données dans un fichier zip que vous pouvez télécharger. Plus tard, vous pouvez télécharger et restaurer la base de données complète. Vous pouvez le trouver dans ma page Github https://github.com/JoshyFrancis/mysql_backup_restore_php
Même s'il s'agit d'un ancien sujet, je ne pouvais pas utiliser les réponses postées ici (Sorry My Bad). Mais voici le script que j'utilise des bases de données MySQL de sauvegarde,
Jetez un oeil here! C'est une solution native écrite en PHP. Vous n'aurez pas besoin d'exécuter mysqldump, ou de gérer des scripts incomplets. C'est un clone mysqldump complet, sans dépendances, compression de sortie et valeurs par défaut saines. En sortie de boîte, mysqldump-php prend en charge la sauvegarde des structures de table, des données elles-mêmes, des vues, des déclencheurs et des événements.
Mysqldump-PHP est la seule bibliothèque qui prend en charge:
Vous pouvez l'installer à l'aide compositeur, ou tout simplement télécharger le fichier php, et il est aussi facile que faire:
use Ifsnop\Mysqldump as IMysqldump;
try {
$dump = new IMysqldump\Mysqldump('database', 'username', 'password');
$dump->start('storage/work/dump.sql');
} catch (\Exception $e) {
echo 'mysqldump-php error: ' . $e->getMessage();
}
Toutes les options sont expliqués à la page GitHub, mais plus ou moins sont auto-explicatif:
$dumpSettingsDefault = array(
'include-tables' => array(),
'exclude-tables' => array(),
'compress' => Mysqldump::NONE,
'init_commands' => array(),
'no-data' => array(),
'reset-auto-increment' => false,
'add-drop-database' => false,
'add-drop-table' => false,
'add-drop-trigger' => true,
'add-locks' => true,
'complete-insert' => false,
'databases' => false,
'default-character-set' => Mysqldump::UTF8,
'disable-keys' => true,
'extended-insert' => true,
'events' => false,
'hex-blob' => true, /* faster than escaped content */
'net_buffer_length' => self::MAXLINESIZE,
'no-autocommit' => true,
'no-create-info' => false,
'lock-tables' => true,
'routines' => false,
'single-transaction' => true,
'skip-triggers' => false,
'skip-tz-utc' => false,
'skip-comments' => false,
'skip-dump-date' => false,
'skip-definer' => false,
'where' => '',
/* deprecated */
'disable-foreign-keys-check' => true
);
Voulez-vous le faire avec phpmyadmin ou directement en PHP? –
en PHP, traitaient avec les utilisateurs, donc très probablement nous allons utiliser la sauvegarde automatisée en utilisant des scripts PHP. – user225269
Veuillez noter que les solutions PHP pure ci-dessous supposent que l'ordre des tables n'est pas important. Si vous avez des clés étrangères dans votre base de données, l'ordre de la restauration est important. Mais je n'ai pas trouvé de solution à ce problème spécifique ... MysqlDump fait ça, et phpmyadmin aussi. Bien qu'ils ne soient pas de simples solutions PHP. – jehon