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

php mysql备份恢复分卷处理

发布:smiling　来源: PHP粉丝网 　添加日期：2014-09-10 13:58:41　浏览: 评论：0　

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

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

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

分享到：

推荐文章

热门文章

最新评论文章