当前位置：首页 > PHP教程 > php应用 > 列表

php实现mysql备份恢复分卷处理的方法

发布:smiling　来源: PHP粉丝网 　添加日期：2021-05-04 18:49:54　浏览: 评论：0　

这篇文章主要介绍了php实现mysql备份恢复分卷处理的方法,包括完整的MySQL备份恢复类文件及用法实例,注释包含了详尽的用法说明,是非常实用的技巧,需要的朋友可以参考下

本文实例讲述了php实现mysql备份恢复分卷处理的方法。分享给大家供大家参考。具体分析如下：

分卷处理就是把握们要处理的数据分成一个个小文件进行处理了,这里我来给大家介绍一个php mysql备份恢复分卷处理类,实现mysql数据库分卷备份,选择表进行备份,实现单个sql文件及分卷sql导入.

分卷导入类及思路详解

数据库导入导出是一个后台必要拥有的功能,网上一搜,有很多关于数据库导入导出的,但基本上一个大的系统,包含了许多我们并不需要的,而且他们都是自己的后台的形式,我并不喜欢的是拿人家的东西整合到自己的后台,我需要的是自己东西,于是参照了很多,自己写了一个关于分卷导入类,以方便调用,欢迎大家拍砖.

这里针对分卷文件是以‘_v1.sql'为结尾,实现单个sql文件及分卷sql导入,分卷导入可选择是否当前分卷导入余下分卷,我们只需要直接调用类即可完成.

分别是主机，用户名，密码，数据库名，数据库编码

代码如下:

$db = new DataManage ( 'localhost', 'root', 'root', 'test', 'utf8' );

sql文件,是否只导入单个sql(即如果有其他分卷也不导入).

代码如下:

$db->restore ( './backup/20120516211738_all_v1.sql', false );

对应如何去列出备份的sql文件或选择sql之类的,自己去实现,那个不在这个范畴了,也很简单的.

还有目前只实现了数据库导入,关于数据库导出的,正在编写功能,下面是完整的类代码,具体思路及实现代码里面都有说明,这里不在赘述,代码如下:

  1. <?php 
  2. /** 
  3.  * @author yanue 
  4.  * 说明：分卷文件是以_v1.sql为结尾 
  5.  * 功能：实现单个sql文件及分卷sql导入,分卷导入可选择是否当前分卷导入余下分卷 
  6.  * 使用方法： 
  7.  * 
  8.  * 
  9.  * ------------------------------------------------------------------ 
  10. //分别是主机，用户名，密码，数据库名，数据库编码 
  11. $db = new DataManage ( 'localhost', 'root', 'root', 'test', 'utf8' ); 
  12. //sql文件，是否只导入单个sql（即如果有其他分卷也不导入） 
  13. $db->restore ( './backup/20120516211738_all_v1.sql', false ); 
  14.  *---------------------------------------------------------------------- 
  15.  */ 
  16. class DataManage { 
  17.  var $db; // 数据库连接 
  18.  var $database; // 所用数据库 
  19.  var $sqldir; // 数据库备份文件夹 
  20.  
  21.  /** 
  22.   * 初始化 
  23.   * 
  24.   * @param string $host 
  25.   * @param string $username 
  26.   * @param string $password 
  27.   * @param string $database 
  28.   * @param string $charset 
  29.   */ 
  30.  function __construct($host = 'localhost', $username = 'root', $password = '', $database = 'test', $charset = 'utf8') { 
  31.   $this->host = $host; 
  32.   $this->username = $username; 
  33.   $this->password = $password; 
  34.   $this->database = $database; 
  35.   $this->charset = $charset; 
  36.   // 连接数据库 
  37.   $this->db = mysql_connect ( $this->host, $this->username, $this->password ) or die ( "数据库连接失败." ); 
  38.   // 选择使用哪个数据库 
  39.   mysql_select_db ( $this->database, $this->db ) or die ( "无法打开数据库" ); 
  40.   // 数据库编码方式 
  41.   mysql_query ( 'SET NAMES ' . $this->charset, $this->db ); 
  42.  } 
  43.  
  44.  /** 
  45.   * 导入备份数据 
  46.   * 说明：分卷文件格式20120516211738_all_v1.sql 
  47.   * 
  48.   * @param string $sqlfile 
  49.   * @param bool $single 
  50.   */ 
  51.  function restore($sqlfile, $single = FALSE) { 
  52.   // 检测文件是否存在 
  53.   if (! file_exists ( $sqlfile )) { 
  54.    exit ( "文件不存在！请检查" ); 
  55.   } 
  56.   $this->lock ( $this->database ); 
  57.   // 获取数据库存储位置 
  58.   $sqlpath = pathinfo ( $sqlfile ); 
  59.   $this->sqldir = $sqlpath ['dirname']; 
  60.   // 检测是否包含分卷，将类似20120516211738_all_v1.sql从_v分开,有则说明有分卷 
  61.   $volume = explode ( "_v", $sqlfile ); 
  62.   $volume_path = $volume [0]; 
  63.   echo "请勿刷新及关闭浏览器以防止程序被中止，如有不慎！将导致数据库结构受损<br />"; 
  64.   echo "正在导入备份数据，请稍等！<br />"; 
  65.   if (emptyempty ( $volume [1] ) || $single) { 
  66.    echo "正在导入sql：<span style='color:#f00;'>" . $sqlfile . '</span><br />'; 
  67.    // 没有分卷 
  68.    if ($this->_import ( $sqlfile )) { 
  69.     echo "数据库导入成功！"; 
  70.    } else { 
  71.     exit ( '数据库导入失败！' ); 
  72.    } 
  73.   } else { 
  74.    // 存在分卷，则获取当前是第几分卷，循环执行余下分卷 
  75.    $volume_id = explode ( ".sq", $volume [1] ); 
  76.    // 当前分卷为$volume_id 
  77.    $volume_id = intval ( $volume_id [0] ); 
  78.    while ( $volume_id ) { 
  79.     $tmpfile = $volume_path . "_v" . $volume_id . ".sql"; 
  80.     // 存在其他分卷，继续执行 
  81.     if (file_exists ( $tmpfile )) { 
  82.      // 执行导入方法 
  83.      echo "正在导入分卷$volume_id：<span style='color:#f00;'>" . $tmpfile . '</span><br />'; 
  84.      if ($this->_import ( $tmpfile )) { 
  85.  
  86.      } else { 
  87.       exit ( "导入分卷$volume_id：<span style='color:#f00;'>" . $tmpfile . '</span>失败！可能是数据库结构已损坏！请尝试从分卷1开始导入' ); 
  88.      } 
  89.     } else { 
  90.      echo "此分卷备份全部导入成功！<br />"; 
  91.      return; 
  92.     } 
  93.     $volume_id ++; 
  94.    } 
  95.   } 
  96.  } 
  97.  
  98.  /** 
  99.   * 将sql导入到数据库（普通导入） 
  100.   * 
  101.   * @param string $sqlfile 
  102.   * @return boolean 
  103.   */ 
  104.  private function _import($sqlfile) { 
  105.   $name = basename ( $sqlfile ); 
  106.   $sqls = file ( $sqlfile ); 
  107.   foreach ( $sqls as $sql ) { 
  108.    str_replace ( "r", "", $sql ); 
  109.    str_replace ( "n", "", $sql ); 
  110.    if (! mysql_query ( trim ( $sql ), $this->db )) 
  111.     return false; 
  112.   } 
  113.   return true; 
  114.  } 
  115.  
  116.  // 关闭数据库连接 
  117.  private function close() { 
  118.   mysql_close ( $this->db ); 
  119.  } 
  120.  
  121.  // 锁定数据库，以免备份或导入时出错 
  122.  private function lock($tablename, $op = "WRITE") { 
  123.   if (mysql_query ( "lock tables " . $tablename . " " . $op )) 
  124.    return true; 
  125.   else 
  126.    return false; 
  127.  } 
  128.  
  129.  // 解锁 
  130.  private function unlock() { 
  131.   if (mysql_query ( "unlock tables" )) 
  132.    return true; 
  133.   else 
  134.    return false; 
  135.  } 
  136.  
  137.  // 析构 
  138.  function __destruct() { 
  139.   mysql_query ( "unlock tables", $this->db ); 
  140.   mysql_close ( $this->db ); 
  141.  } 
  142. } 
  143. ?> 

mysql备份恢复分卷处理,调用简单.

分卷导入思路:

按行读取sql文件,将每一行当作完整的sql语句存到数组再循环执行插入数据库就可以了,但是在创建表语句分了多行,这个需要单独处理,就这个花了我好长时间的.感觉文章好长啊,主要是那个类文件给占用了.

更新说明:

1.去除sql导入的时候排除sql文件里面的注释'– ‘ 从而解决sql中单双引号不能导入

2.单行读取后的sql直接执行,避免重新将sql语句组合到数组中再从数组中读取导入sql,提高效率.

下载地址: https://github.com/yanue/Dbmanage

导出后的sql文件格式如下:

  1. -- 
  2. -- MySQL database dump 
  3. -- Created by DBManage class, Power By yanue.  
  4. -- 
  5. -- 主机: localhost 
  6. -- 生成日期: 2012 年  10 月 06 日 22:32 
  7. -- MySQL版本: 5.1.50-community 
  8. -- PHP 版本: 5.3.9-ZS5.6.0 
  9.  
  10. -- 
  11. -- 数据库: `test` 
  12. -- 
  13.  
  14. -- ------------------------------------------------------- 
  15.  
  16. -- 
  17. -- 表的结构aa 
  18. -- 
  19.  
  20. DROP TABLE IF EXISTS `aa`; 
  21. CREATE TABLE `aa` ( 
  22.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT, 
  23.   `content` text NOT NULL, 
  24.   PRIMARY KEY (`id`) 
  25. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; 
  26.  
  27. -- 
  28. -- 转存表中的数据 aa 
  29. -- 
  30.  
  31. INSERT INTO `aa` VALUES('1','<p id="test"><span class='hahh' style="line-height:;">我是测试数据 呵呵</span></p>'); 

下面是类代码:

  1. <?php 
  2. /** 
  3.  * @author yanue 
  4.  * @copyright  Copyright (c) 2012 yanue.net 
  5.  * @version 1.1 
  6.  * 创建时间： 2012年5月21日 
  7.  
  8. 更新时间： 2012年10月6日 
  9. 更新说明： 1.去除sql导入的时候排除sql文件里面的注释'-- ' 从而解决sql中单双引号不能导入 
  10. 2.单行读取后的sql直接执行，避免重新将sql语句组合到数组中再从数组中读取导入sql，提高效率 
  11.  
  12.  * 说明：分卷文件是以_v1.sql为结尾(20120522021241_all_v1.sql) 
  13.  * 功能：实现mysql数据库分卷备份,选择表进行备份,实现单个sql文件及分卷sql导入 
  14.  * 使用方法： 
  15.  * 
  16.  * ------1. 数据库备份（导出）------------------------------------------------------------ 
  17. //分别是主机，用户名，密码，数据库名，数据库编码 
  18. $db = new DBManage ( 'localhost', 'root', 'root', 'test', 'utf8' ); 
  19. // 参数：备份哪个表(可选),备份目录(可选，默认为backup),分卷大小(可选,默认2000，即2M) 
  20. $db->backup (); 
  21.  * ------2. 数据库恢复（导入）------------------------------------------------------------ 
  22. //分别是主机，用户名，密码，数据库名，数据库编码 
  23. $db = new DBManage ( 'localhost', 'root', 'root', 'test', 'utf8' ); 
  24. //参数：sql文件 
  25. $db->restore ( './backup/20120516211738_all_v1.sql'); 
  26.  *---------------------------------------------------------------------- 
  27.  */ 
  28. class DbManage { 
  29.     var $db; // 数据库连接 
  30.     var $database; // 所用数据库 
  31.     var $sqldir; // 数据库备份文件夹 
  32.     // 换行符 
  33.     private $ds = "n"; 
  34.     // 存储SQL的变量 
  35.     public $sqlContent = ""; 
  36.     // 每条sql语句的结尾符 
  37.     public $sqlEnd = ";"; 
  38.  
  39.     /** 
  40.      * 初始化 
  41.      * 
  42.      * @param string $host 
  43.      * @param string $username 
  44.      * @param string $password 
  45.      * @param string $database 
  46.      * @param string $charset 
  47.      */ 
  48.     function __construct($host = 'localhost', $username = 'root', $password = '', $database = 'test', $charset = 'utf8') { 
  49.         $this->host = $host; 
  50.         $this->username = $username; 
  51.         $this->password = $password; 
  52.         $this->database = $database; 
  53.         $this->charset = $charset; 
  54.         set_time_limit(0);//无时间限制 
  55. @ob_end_flush(); 
  56.         // 连接数据库 
  57.         $this->db = @mysql_connect ( $this->host, $this->username, $this->password ) or die( '<p class="dbDebug"><span class="err">Mysql Connect Error : </span>'.mysql_error().'</p>'); 
  58.         // 选择使用哪个数据库 
  59.         mysql_select_db ( $this->database, $this->db ) or die('<p class="dbDebug"><span class="err">Mysql Connect Error:</span>'.mysql_error().'</p>'); 
  60.         // 数据库编码方式 
  61.         mysql_query ( 'SET NAMES ' . $this->charset, $this->db ); 
  62.  
  63.     } 
  64.  
  65.     /* 
  66.      * 新增查询数据库表 
  67.      */ 
  68.     function getTables() { 
  69.         $res = mysql_query ( "SHOW TABLES" ); 
  70.         $tables = array (); 
  71.         while ( $row = mysql_fetch_array ( $res ) ) { 
  72.             $tables [] = $row [0]; 
  73.         } 
  74.         return $tables; 
  75.     } 
  76.  
  77.     /* 
  78.      * 
  79.      * ------------------------------------------数据库备份start---------------------------------------------------------- 
  80.      */ 
  81.  
  82.     /** 
  83.      * 数据库备份 
  84.      * 参数：备份哪个表(可选),备份目录(可选，默认为backup),分卷大小(可选,默认2000，即2M) 
  85.      * 
  86.      * @param $string $dir 
  87.      * @param int $size 
  88.      * @param $string $tablename 
  89.      */ 
  90.     function backup($tablename = '', $dir, $size) { 
  91.         $dir = $dir ? $dir : './backup/'; 
  92.         // 创建目录 
  93.         if (! is_dir ( $dir )) { 
  94.             mkdir ( $dir, 0777, true ) or die ( '创建文件夹失败' ); 
  95.         } 
  96.         $size = $size ? $size : 2048; 
  97.         $sql = ''; 
  98.         // 只备份某个表 
  99.         if (! emptyempty ( $tablename )) { 
  100.             if(@mysql_num_rows(mysql_query("SHOW TABLES LIKE '".$tablename."'")) == 1) { 
  101.              } else { 
  102.                 $this->_showMsg('表-<b>' . $tablename .'</b>-不存在，请检查！',true); 
  103.                 die(); 
  104.             } 
  105.             $this->_showMsg('正在备份表 <span class="imp">' . $tablename.'</span>'); 
  106.             // 插入dump信息 
  107.             $sql = $this->_retrieve (); 
  108.             // 插入表结构信息 
  109.             $sql .= $this->_insert_table_structure ( $tablename ); 
  110.             // 插入数据 
  111.             $data = mysql_query ( "select * from " . $tablename ); 
  112.             // 文件名前面部分 
  113.             $filename = date ( 'YmdHis' ) . "_" . $tablename; 
  114.             // 字段数量 
  115.             $num_fields = mysql_num_fields ( $data ); 
  116.             // 第几分卷 
  117.             $p = 1; 
  118.             // 循环每条记录 
  119.             while ( $record = mysql_fetch_array ( $data ) ) { 
  120.                 // 单条记录 
  121.                 $sql .= $this->_insert_record ( $tablename, $num_fields, $record ); 
  122.                 // 如果大于分卷大小，则写入文件 
  123.                 if (strlen ( $sql ) >= $size * 1024) { 
  124.                     $file = $filename . "_v" . $p . ".sql"; 
  125.                     if ($this->_write_file ( $sql, $file, $dir )) { 
  126.                         $this->_showMsg("表-<b>" . $tablename . "</b>-卷-<b>" . $p . "</b>-数据备份完成,备份文件 [ <span class='imp'>" .$dir . $file ."</span> ]"); 
  127.                     } else { 
  128.                         $this->_showMsg("备份表 -<b>" . $tablename . "</b>- 失败",true); 
  129.                         return false; 
  130.                     } 
  131.                     // 下一个分卷 
  132.                     $p ++; 
  133.                     // 重置$sql变量为空，重新计算该变量大小 
  134.                     $sql = ""; 
  135.                 } 
  136.             } 
  137.             // 及时清除数据 
  138.             unset($data,$record); 
  139.             // sql大小不够分卷大小 
  140.             if ($sql != "") { 
  141.                 $filename .= "_v" . $p . ".sql"; 
  142.                 if ($this->_write_file ( $sql, $filename, $dir )) { 
  143.                     $this->_showMsg( "表-<b>" . $tablename . "</b>-卷-<b>" . $p . "</b>-数据备份完成,备份文件 [ <span class='imp'>" .$dir . $filename ."</span> ]"); 
  144.                 } else { 
  145.                     $this->_showMsg("备份卷-<b>" . $p . "</b>-失败<br />"); 
  146.                     return false; 
  147.                 } 
  148.             } 
  149.             $this->_showMsg("恭喜您! <span class='imp'>备份成功</span>"); 
  150.         } else { 
  151.             $this->_showMsg('正在备份'); 
  152.             // 备份全部表 
  153.             if ($tables = mysql_query ( "show table status from " . $this->database )) { 
  154.                 $this->_showMsg("读取数据库结构成功！"); 
  155.             } else { 
  156.                 $this->_showMsg("读取数据库结构失败！"); 
  157.                 exit ( 0 ); 
  158.             } 
  159.             // 插入dump信息 
  160.             $sql .= $this->_retrieve (); 
  161.             // 文件名前面部分 
  162.             $filename = date ( 'YmdHis' ) . "_all"; 
  163.             // 查出所有表 
  164.             $tables = mysql_query ( 'SHOW TABLES' ); 
  165.             // 第几分卷 
  166.             $p = 1; 
  167.             // 循环所有表 
  168.             while ( $table = mysql_fetch_array ( $tables ) ) { 
  169.                 // 获取表名 
  170.                 $tablename = $table [0]; 
  171.                 // 获取表结构 
  172.                 $sql .= $this->_insert_table_structure ( $tablename ); 
  173.                 $data = mysql_query ( "select * from " . $tablename ); 
  174.                 $num_fields = mysql_num_fields ( $data ); 
  175.  
  176.                 // 循环每条记录 
  177.                 while ( $record = mysql_fetch_array ( $data ) ) { 
  178.                     // 单条记录 
  179.                     $sql .= $this->_insert_record ( $tablename, $num_fields, $record ); 
  180.                     // 如果大于分卷大小，则写入文件 
  181.                     if (strlen ( $sql ) >= $size * 1000) { 
  182.  
  183.                         $file = $filename . "_v" . $p . ".sql"; 
  184.                         // 写入文件 
  185.                         if ($this->_write_file ( $sql, $file, $dir )) { 
  186.                             $this->_showMsg("-卷-<b>" . $p . "</b>-数据备份完成,备份文件 [ <span class='imp'>".$dir.$file."</span> ]"); 
  187.                         } else { 
  188.                             $this->_showMsg("卷-<b>" . $p . "</b>-备份失败!",true); 
  189.                             return false; 
  190.                         } 
  191.                         // 下一个分卷 
  192.                         $p ++; 
  193.                         // 重置$sql变量为空，重新计算该变量大小 
  194.                         $sql = ""; 
  195.                     } 
  196.                 } 
  197.             } 
  198.             // sql大小不够分卷大小 
  199.             if ($sql != "") { 
  200.                 $filename .= "_v" . $p . ".sql"; 
  201.                 if ($this->_write_file ( $sql, $filename, $dir )) { 
  202.                     $this->_showMsg("-卷-<b>" . $p . "</b>-数据备份完成,备份文件 [ <span class='imp'>".$dir.$filename."</span> ]"); 
  203.                 } else { 
  204.                     $this->_showMsg("卷-<b>" . $p . "</b>-备份失败",true); 
  205.                     return false; 
  206.                 } 
  207.             } 
  208.             $this->_showMsg("恭喜您! <span class='imp'>备份成功</span>"); 
  209.         } 
  210.     } 
  211.  
  212.     //  及时输出信息 
  213.     private function _showMsg($msg,$err=false){ 
  214.         $err = $err ? "<span class='err'>ERROR:</span>" : '' ; 
  215.         echo "<p class='dbDebug'>".$err . $msg."</p>"; 
  216.         flush(); 
  217.  
  218.     } 
  219.  
  220.     /** 
  221.      * 插入数据库备份基础信息 
  222.      * 
  223.      * @return string 
  224.      */ 
  225.     private function _retrieve() { 
  226.         $value = ''; 
  227.         $value .= '--' . $this->ds; 
  228.         $value .= '-- MySQL database dump' . $this->ds; 
  229.         $value .= '-- Created by DbManage class, Power By yanue. ' . $this->ds; 
  230.         $value .= '-- http://yanue.net ' . $this->ds; 
  231.         $value .= '--' . $this->ds; 
  232.         $value .= '-- 主机: ' . $this->host . $this->ds; 
  233.         $value .= '-- 生成日期: ' . date ( 'Y' ) . ' 年  ' . date ( 'm' ) . ' 月 ' . date ( 'd' ) . ' 日 ' . date ( 'H:i' ) . $this->ds; 
  234.         $value .= '-- MySQL版本: ' . mysql_get_server_info () . $this->ds; 
  235.         $value .= '-- PHP 版本: ' . phpversion () . $this->ds; 
  236.         $value .= $this->ds; 
  237.         $value .= '--' . $this->ds; 
  238.         $value .= '-- 数据库: `' . $this->database . '`' . $this->ds; 
  239.         $value .= '--' . $this->ds . $this->ds; 
  240.         $value .= '-- -------------------------------------------------------'; 
  241.         $value .= $this->ds . $this->ds; 
  242.         return $value; 
  243.     } 
  244.  
  245.     /** 
  246.      * 插入表结构 
  247.      * 
  248.      * @param unknown_type $table 
  249.      * @return string 
  250.      */ 
  251.     private function _insert_table_structure($table) { 
  252.         $sql = ''; 
  253.         $sql .= "--" . $this->ds; 
  254.         $sql .= "-- 表的结构" . $table . $this->ds; 
  255.         $sql .= "--" . $this->ds . $this->ds; 
  256.  
  257.         // 如果存在则删除表 
  258.         $sql .= "DROP TABLE IF EXISTS `" . $table . '`' . $this->sqlEnd . $this->ds; 
  259.         // 获取详细表信息 
  260.         $res = mysql_query ( 'SHOW CREATE TABLE `' . $table . '`' ); 
  261.         $row = mysql_fetch_array ( $res ); 
  262.         $sql .= $row [1]; 
  263.         $sql .= $this->sqlEnd . $this->ds; 
  264.         // 加上 
  265.         $sql .= $this->ds; 
  266.         $sql .= "--" . $this->ds; 
  267.         $sql .= "-- 转存表中的数据 " . $table . $this->ds; 
  268.         $sql .= "--" . $this->ds; 
  269.         $sql .= $this->ds; 
  270.         return $sql; 
  271.     } 
  272.  
  273.     /** 
  274.      * 插入单条记录 
  275.      * 
  276.      * @param string $table 
  277.      * @param int $num_fields 
  278.      * @param array $record 
  279.      * @return string 
  280.      */ 
  281.     private function _insert_record($table, $num_fields, $record) { 
  282.         // sql字段逗号分割 
  283.         $insert = ''; 
  284.         $comma = ""; 
  285.         $insert .= "INSERT INTO `" . $table . "` VALUES("; 
  286.         // 循环每个子段下面的内容 
  287.         for($i = 0; $i < $num_fields; $i ++) { 
  288.             $insert .= ($comma . "'" . mysql_escape_string ( $record [$i] ) . "'"); 
  289.             $comma = ","; 
  290.         } 
  291.         $insert .= ");" . $this->ds; 
  292.         return $insert; 
  293.     } 
  294.  
  295.     /** 
  296.      * 写入文件 
  297.      * 
  298.      * @param string $sql 
  299.      * @param string $filename 
  300.      * @param string $dir 
  301.      * @return boolean 
  302.      */ 
  303.     private function _write_file($sql, $filename, $dir) { 
  304.         $dir = $dir ? $dir : './backup/'; 
  305.         // 创建目录 
  306.         if (! is_dir ( $dir )) { 
  307.             mkdir ( $dir, 0777, true ); 
  308.         } 
  309.         $re = true; 
  310.         if (! @$fp = fopen ( $dir . $filename, "w+" )) { 
  311.             $re = false; 
  312.             $this->_showMsg("打开sql文件失败！",true); 
  313.         } 
  314.         if (! @fwrite ( $fp, $sql )) { 
  315.             $re = false; 
  316.             $this->_showMsg("写入sql文件失败，请文件是否可写",true); 
  317.         } 
  318.         if (! @fclose ( $fp )) { 
  319.             $re = false; 
  320.             $this->_showMsg("关闭sql文件失败！",true); 
  321.         } 
  322.         return $re; 
  323.     } 
  324.  
  325.     /* 
  326.      * 
  327.      * -------------------------------上：数据库导出-----------分割线----------下：数据库导入-------------------------------- 
  328.      */ 
  329.  
  330.     /** 
  331.      * 导入备份数据 
  332.      * 说明：分卷文件格式20120516211738_all_v1.sql 
  333.      * 参数：文件路径(必填) 
  334.      * 
  335.      * @param string $sqlfile 
  336.      */ 
  337.     function restore($sqlfile) { 
  338.         // 检测文件是否存在 
  339.         if (! file_exists ( $sqlfile )) { 
  340.             $this->_showMsg("sql文件不存在！请检查",true); 
  341.             exit (); 
  342.         } 
  343.         $this->lock ( $this->database ); 
  344.         // 获取数据库存储位置 
  345.         $sqlpath = pathinfo ( $sqlfile ); 
  346.         $this->sqldir = $sqlpath ['dirname']; 
  347.         // 检测是否包含分卷，将类似20120516211738_all_v1.sql从_v分开,有则说明有分卷 
  348.         $volume = explode ( "_v", $sqlfile ); 
  349.         $volume_path = $volume [0]; 
  350.         $this->_showMsg("请勿刷新及关闭浏览器以防止程序被中止，如有不慎！将导致数据库结构受损"); 
  351.         $this->_showMsg("正在导入备份数据，请稍等！"); 
  352.         if (emptyempty ( $volume [1] )) { 
  353.             $this->_showMsg ( "正在导入sql：<span class='imp'>" . $sqlfile . '</span>'); 
  354.             // 没有分卷 
  355.             if ($this->_import ( $sqlfile )) { 
  356.                 $this->_showMsg( "数据库导入成功！"); 
  357.             } else { 
  358.                  $this->_showMsg('数据库导入失败！',true); 
  359.                 exit (); 
  360.             } 
  361.         } else { 
  362.             // 存在分卷，则获取当前是第几分卷，循环执行余下分卷 
  363.             $volume_id = explode ( ".sq", $volume [1] ); 
  364.             // 当前分卷为$volume_id 
  365.             $volume_id = intval ( $volume_id [0] ); 
  366.             while ( $volume_id ) { 
  367.                 $tmpfile = $volume_path . "_v" . $volume_id . ".sql"; 
  368.                 // 存在其他分卷，继续执行 
  369.                 if (file_exists ( $tmpfile )) { 
  370.                     // 执行导入方法 
  371.                     $this->msg .= "正在导入分卷 $volume_id ：<span style='color:#f00;'>" . $tmpfile . '</span><br />'; 
  372.                     if ($this->_import ( $tmpfile )) { 
  373.  
  374.                     } else { 
  375.                         $volume_id = $volume_id ? $volume_id :1; 
  376.                         exit ( "导入分卷：<span style='color:#f00;'>" . $tmpfile . '</span>失败！可能是数据库结构已损坏！请尝试从分卷1开始导入' ); 
  377.                     } 
  378.                 } else { 
  379.                     $this->msg .= "此分卷备份全部导入成功！<br />"; 
  380.                     return; 
  381.                 } 
  382.                 $volume_id ++; 
  383.             } 
  384.         }if (emptyempty ( $volume [1] )) { 
  385.             $this->_showMsg ( "正在导入sql：<span class='imp'>" . $sqlfile . '</span>'); 
  386.             // 没有分卷 
  387.             if ($this->_import ( $sqlfile )) { 
  388.                 $this->_showMsg( "数据库导入成功！"); 
  389.             } else { 
  390.                  $this->_showMsg('数据库导入失败！',true); 
  391.                 exit (); 
  392.             } 
  393.         } else { 
  394.             // 存在分卷，则获取当前是第几分卷，循环执行余下分卷 
  395.             $volume_id = explode ( ".sq", $volume [1] ); 
  396.             // 当前分卷为$volume_id 
  397.             $volume_id = intval ( $volume_id [0] ); 
  398.             while ( $volume_id ) { 
  399.                 $tmpfile = $volume_path . "_v" . $volume_id . ".sql"; 
  400.                 // 存在其他分卷，继续执行 
  401.                 if (file_exists ( $tmpfile )) { 
  402.                     // 执行导入方法 
  403.                     $this->msg .= "正在导入分卷 $volume_id ：<span style='color:#f00;'>" . $tmpfile . '</span><br />'; 
  404.                     if ($this->_import ( $tmpfile )) { 
  405.  
  406.                     } else { 
  407.                         $volume_id = $volume_id ? $volume_id :1; 
  408.                         exit ( "导入分卷：<span style='color:#f00;'>" . $tmpfile . '</span>失败！可能是数据库结构已损坏！请尝试从分卷1开始导入' ); 
  409.                     } 
  410.                 } else { 
  411.                     $this->msg .= "此分卷备份全部导入成功！<br />"; 
  412.                     return; 
  413.                 } 
  414.                 $volume_id ++; 
  415.             } 
  416.         } 
  417.     } 
  418.  
  419.     /** 
  420.      * 将sql导入到数据库（普通导入） 
  421.      * 
  422.      * @param string $sqlfile 
  423.      * @return boolean 
  424.      */ 
  425.     private function _import($sqlfile) { 
  426.         // sql文件包含的sql语句数组 
  427.         $sqls = array (); 
  428.         $f = fopen ( $sqlfile, "rb" ); 
  429.         // 创建表缓冲变量 
  430.         $create_table = ''; 
  431.         while ( ! feof ( $f ) ) { 
  432.             // 读取每一行sql 
  433.             $line = fgets ( $f ); 
  434.             // 这一步为了将创建表合成完整的sql语句 
  435.             // 如果结尾没有包含';'(即为一个完整的sql语句，这里是插入语句)，并且不包含'ENGINE='(即创建表的最后一句) 
  436.             if (! preg_match ( '/;/', $line ) || preg_match ( '/ENGINE=/', $line )) { 
  437.                 // 将本次sql语句与创建表sql连接存起来 
  438.                 $create_table .= $line; 
  439.                 // 如果包含了创建表的最后一句 
  440.                 if (preg_match ( '/ENGINE=/', $create_table)) { 
  441.                     //执行sql语句创建表 
  442.                     $this->_insert_into($create_table); 
  443.                     // 清空当前，准备下一个表的创建 
  444.                     $create_table = ''; 
  445.                 } 
  446.                 // 跳过本次 
  447.                 continue; 
  448.             } 
  449.             //执行sql语句 
  450.             $this->_insert_into($line); 
  451.         } 
  452.         fclose ( $f ); 
  453.         return true; 
  454.     } 
  455.  
  456.     //插入单条sql语句 
  457.     private function _insert_into($sql){ 
  458.         if (! mysql_query ( trim ( $sql ) )) { 
  459.             $this->msg .= mysql_error (); 
  460.             return false; 
  461.         } 
  462.     } 
  463.  
  464.     /* 
  465.      * -------------------------------数据库导入end--------------------------------- 
  466.      */ 
  467.  
  468.     // 关闭数据库连接 
  469.     private function close() { 
  470.         mysql_close ( $this->db ); 
  471.     } 
  472.  
  473.     // 锁定数据库，以免备份或导入时出错 
  474.     private function lock($tablename, $op = "WRITE") { 
  475.         if (mysql_query ( "lock tables " . $tablename . " " . $op )) 
  476.             return true; 
  477.         else 
  478.             return false; 
  479.     } 
  480.  
  481.     // 解锁 
  482.     private function unlock() { 
  483.         if (mysql_query ( "unlock tables" )) 
  484.             return true; 
  485.         else 
  486.             return false; 
  487.     } 
  488.  
  489.     // 析构 
  490.     function __destruct() { 
  491.         if($this->db){ 
  492.             mysql_query ( "unlock tables", $this->db ); 
  493.             mysql_close ( $this->db ); 
  494.         } 
  495.     } 
  496. } 
  497. ?>

Tags: mysql备份恢复 mysql分卷处理

分享到：

推荐文章

热门文章

最新评论文章