数据库操作类

http://blog.csdn.net/linvo/article/details/4825933

数据库操作类：DBCommon.class.php

view plain print ?

1.  //---------------------------------------------------------------------    
2.  //      MySQL Master/Slave数据库读写操作类    
3.  //    
4.  // 开发作者: heiyeluren    
5.  // 版本历史:     
6.  //          2006-09-20  基本单数据库操作功能, 25 个接口    
7.  //          2007-07-30  支持单Master/多Slave数据库操作，29个接口    
8.  //          2008-09-07  修正了上一版本的部分Bug    
9.  //          2009-11-17  在Master/Slave类的基础上增加了强化单主机操作，    
10.  //                  增加了部分简洁操作接口和调试接口，优化了部分代码，    
11.  //                  本版本共42个接口    
12.  // 应用项目: Y!NCP, Y!SNS, TM MiniSite//    
13.  // 功能描述：自动支持Master/Slave 读/写 分离操作，支持多Slave主机    
14.  //    
15.  //-----------------------------------------------------------------------    
16.          
17.      
18.          
19.  /**  
20.   * 常量定义  
21.   */    
22.  define("_DB_INSERT", 1);    
23.  define("_DB_UPDATE", 2);    
24.          
25.          
26.  /**  
27.   * DB Common class  
28.   *  
29.   * 描述：能够分别处理一台Master写操作，多台Slave读操作  
30.   */    
31.  class DBCommon    
32.  {    
33.      /**  
34.       * 数据库配置信息  
35.       */    
36.      var $wdbConf = array();    
37.      var $rdbConf = array();    
38.      /**  
39.       * Master数据库连接  
40.       */    
41.      var $wdbConn = null;    
42.      /**  
43.       * Slave数据库连接  
44.       */    
45.      var $rdbConn = array();    
46.      /**  
47.       * 当前操作的数据库链接  
48.       */    
49.      var $currConn = null;    
50.      /**  
51.       * 是否只有一台Master数据库服务器  
52.       */    
53.      var $singleHost = true;    
54.      /**  
55.       * 数据库结果  
56.       */    
57.      var $dbResult;    
58.      /**  
59.       * 数据库查询结果集  
60.       */    
61.      var $dbRecord;    
62.      
63.      /**  
64.       * SQL语句  
65.       */    
66.      var $dbSql;    
67.      /**  
68.       * 数据库编码  
69.       */    
70.      var $dbCharset = "UTF8";    
71.      /**  
72.       * 数据库版本  
73.       */    
74.      var $dbVersion = "5.0";    
75.      
76.      
77.      /**  
78.       * 初始化的时候是否要连接到数据库  
79.       */    
80.      var $isInitConn = false;    
81.      /**  
82.       * 是否要设置字符集  
83.       */    
84.      var $isCharset = false;    
85.      /**  
86.       * 数据库结果集提取方式  
87.       */    
88.      var $fetchMode = MYSQL_ASSOC;    
89.      /**  
90.       * 执行中发生错误是否记录日志  
91.       */    
92.      var $isLog = false;    
93.      /**  
94.       * 执行中的SQL是否记录，设定级别  
95.       *  
96.       * 0:不记录     
97.       * 1:记录insert    
98.       * 2:记录insert/update    
99.       * 3:记录insert/update/delete    
100.       * 4:记录select/insert/update/delete  
101.       */    
102.      var $logSqlLevel = 0;    
103.      /**  
104.       * 记录Log文件路径  
105.       */    
106.      var $logFile = '/tmp/db_common_error.log';    
107.      /**  
108.       * 是否查询出错的时候终止脚本执行  
109.       */    
110.      var $isExit = false;    
111.      /**  
112.       * MySQL执行是否出错了  
113.       */    
114.      var $isError = false;    
115.      /**  
116.       * MySQL执行错误消息  
117.       */    
118.      var $errMsg  = '';    
119.      
120.      
121.      
122.      //------------------------    
123.      //    
124.      //  类本身操作方法    
125.      //    
126.      //------------------------    
127.      
128.      /**  
129.       * 设置类属性  
130.       *  
131.       * @param str $key  需要设置的属性名  
132.       * @param str $value 需要设置的属性值  
133.       * @return void  
134.       */    
135.      function set($key, $value){    
136.          $this->$key = $value;    
137.      }    
138.      
139.      /**  
140.       * 读取类属性  
141.       *  
142.       * @param str $key  需要读取的属性名  
143.       * @return void  
144.       */    
145.      function get($key){    
146.          return $this->$key;    
147.      }    
148.      
149.      
150.      
151.      
152.      //------------------------    
153.      //    
154.      //   基础底层操作接口    
155.      //    
156.      //------------------------    
157.      
158.      /**  
159.       * 构造函数  
160.       *   
161.       * 传递配置信息，配置信息数组结构：  
162.       * $masterConf = array(  
163.       *        "host"    => Master数据库主机地址  
164.       *        "user"    => 登录用户名  
165.       *        "pwd"    => 登录密码  
166.       *        "db"    => 默认连接的数据库  
167.       *    );  
168.       * $slaveConf = array(  
169.       *        "host"    => Slave1数据库主机地址|Slave2数据库主机地址|...  
170.       *        "user"    => 登录用户名  
171.       *        "pwd"    => 登录密码  
172.       *        "db"    => 默认连接的数据库  
173.       *    );  
174.       *  
175.       * @param bool $singleHost  是否只有一台主机  
176.       * @return void  
177.       */    
178.      function DBCommon($masterConf, $slaveConf=array(), $singleHost = true){    
179.          //构造数据库配置信息    
180.          if (is_array($masterConf) && !emptyempty($masterConf)){    
181.              $this->wdbConf = $masterConf;    
182.          }    
183.          if (!is_array($slaveConf) || emptyempty($slaveConf)){    
184.              $this->rdbConf = $masterConf;    
185.          } else {    
186.              $this->rdbConf = $slaveConf;    
187.          }    
188.          $this->singleHost = $singleHost;    
189.          //初始化连接（一般不推荐）    
190.          if ($this->isInitConn){    
191.              $this->getDbWriteConn();  
192. if (!$this->singleHost){ $this->getDbReadConn(); } } } /** * 
193. 获取Master的写数据连接 */ function getDbWriteConn(){ //判断是否已经连接 if  
194. ($this->wdbConn && is_resource($this->wdbConn)) { return  
195. $this->wdbConn; } //没有连接则自行处理 $db =  
196. $this->connect($this->wdbConf['host'], $this->wdbConf['user'],  
197. $this->wdbConf['pwd'], $this->wdbConf['db']); if (!$db ||  
198. !is_resource($db)) { return false; } $this->wdbConn = $db; return  
199. $this->wdbConn; } /** * 获取Slave的读数据连接 */ function getDbReadConn(){  
200. //如果有可用的Slave连接，随机挑选一台Slave if (is_array($this->rdbConn) &&  
201. !emptyempty($this->rdbConn)) { $key = array_rand($this->rdbConn);  
202. if (isset($this->rdbConn[$key]) &&  
203. is_resource($this->rdbConn[$key])) { return $this->rdbConn[$key];  
204. } } //连接到所有Slave数据库，如果没有可用的Slave机则调用Master $arrHost = explode("|",  
205. $this->rdbConf['host']); if (!is_array($arrHost) ||  
206. emptyempty($arrHost)){ return $this->getDbWriteConn(); }  
207. $this->rdbConn = array(); foreach($arrHost as $tmpHost){ $db =  
208. $this->connect($tmpHost, $this->rdbConf['user'],  
209. $this->rdbConf['pwd'], $this->rdbConf['db']); if ($db &&  
210. is_resource($db)){ $this->rdbConn[] = $db; } }  
211. //如果没有一台可用的Slave则调用Master if (!is_array($this->rdbConn) ||  
212. emptyempty($this->rdbConn)){ $this->errorLog("Not availability  
213. slave db connection, call master db connection"); return  
214. $this->getDbWriteConn(); } //随机在已连接的Slave机中选择一台 $key =  
215. array_rand($this->rdbConn); if (isset($this->rdbConn[$key])  
216. && is_resource($this->rdbConn[$key])){ return  
217. $this->rdbConn[$key]; }  
218. //如果选择的slave机器是无效的，并且可用的slave机器大于一台则循环遍历所有能用的slave机器 if  
219. (count($this->rdbConn) > 1){ foreach($this->rdbConn as $conn){  
220. if (is_resource($conn)){ return $conn; } } }  
221. //如果没有可用的Slave连接，则继续使用Master连接 return $this->getDbWriteConn(); } /**  
222. * 连接到MySQL数据库公共方法 */ function connect($dbHost, $dbUser, $dbPasswd,  
223. $dbDatabase){ //连接数据库主机 $db = mysql_connect($dbHost, $dbUser,  
224. $dbPasswd); if (!$db) { $this->errorLog("Mysql connect ". $dbHost ."  
225. failed"); return false; } //选定数据库 if (!mysql_select_db($dbDatabase,  
226. $db)) { $this->errorLog("select db $dbDatabase failed", $db); return  
227. false; } //设置字符集 if ($this->isCharset){ if ( $this->dbVersion ==  
228. '' ){ $res = mysql_query("SELECT VERSION()"); $this->dbVersion =  
229. mysql_result($res, 0); } if ($this->dbCharset!='' &&  
230. preg_match("/^(5.|4.1)/", $this->dbVersion)){ if (mysql_query("SET  
231. NAMES '".$this->dbCharset."'", $db) === false){  
232. $this->errorLog("Set db_host '$dbHost' charset=".  
233. $this->dbCharset ." failed.", $db); return false; } } } return $db;  
234. } /** * 关闭数据库连接 */ function disconnect($dbConn=null, $closeAll=false){  
235. //关闭指定数据库连接 if ($dbConn && is_resource($dbConn)){  
236. mysql_close($dbConn); $dbConn = null; } //关闭所有数据库连接 if ($closeAll){ if  
237. ($this->rdbConn && is_resource($this->rdbConn)){  
238. mysql_close($this->rdbConn); $this->rdbConn = null;    
239.              }    
240.              if (is_array($this->rdbConn) && !emptyempty($this->rdbConn)){    
241.                  foreach($this->rdbConn as $conn){    
242.                      if ($conn && is_resource($conn)){    
243.                          mysql_close($conn);    
244.                      }    
245.                  }    
246.                  $this->rdbConn = array();    
247.              }    
248.          }    
249.          return true;    
250.      }    
251.      
252.      /**  
253.       * 选择数据库  
254.       */    
255.      function selectDb($dbName, $dbConn=null){    
256.          //重新选择一个连接的数据库    
257.          if ($dbConn && is_resource($dbConn)){    
258.              if (!mysql_select_db($dbName, $dbConn)){    
259.                  $this->errorLog("Select database:$dbName failed.", $dbConn);    
260.                  return false;    
261.              }    
262.              return true;    
263.          }    
264.          //重新选择所有连接的数据库    
265.          if ($this->wdbConn && is_resource($this->wdbConn)){    
266.              if (!mysql_select_db($dbName, $this->wdbConn)){    
267.                  $this->errorLog("Select database:$dbName failed.", $this->wdbConn);    
268.                  return false;    
269.              }    
270.          }    
271.          if (is_array($this->rdbConn && !emptyempty($this->rdbConn))){    
272.              foreach($this->rdbConn as $conn){    
273.                  if ($conn && is_resource($conn)){    
274.                      if (!mysql_select_db($dbName, $conn)){    
275.                          $this->errorLog("Select database:$dbName failed.", $conn);    
276.                          return false;    
277.                      }    
278.                  }    
279.              }    
280.          }    
281.          return true;    
282.      }    
283.      
284.      /**  
285.       * 执行SQL语句（底层操作）  
286.       */    
287.      function _query($sql, $isMaster=false){    
288.          if (trim($sql) == ""){    
289.              $this->errorLog("Sql query is empty.");    
290.              return false;    
291.          }    
292.          //是否只有一台数据库机器    
293.          if ($this->singleHost){    
294.              $isMaster = true;       
295.          }    
296.      
297.          //获取执行SQL的数据库连接    
298.          if (!$isMaster){    
299.              $optType = trim(strtolower(substr(ltrim($sql), 0, 6)));    
300.          }    
301.          if ($isMaster || $optType!="select"){    
302.              $dbConn = $this->getDbWriteConn();    
303.          } else {    
304.              $dbConn = $this->getDbReadConn();    
305.          }    
306.          if (!$dbConn || !is_resource($dbConn)){    
307.              $this->isError = true;    
308.              $this->errMsg  = 'Not availability db connection.';    
309.              $this->currConn = null;    
310.      
311.              $this->errorLog("Not availability db connection. Query SQL:". $sql);    
312.              if ($this->isExit) {    
313.                  exit;    
314.              }    
315.              return false;    
316.          }    
317.          //记录执行的SQL    
318.          if ($this->logSqlLevel){    
319.              $isLog = false;    
320.              $logLevel = $this->logSqlLevel;    
321.              if ($logLevel==1 && in_array($optType, array('insert'))){    
322.                  $isLog = true;    
323.              }    
324.              if ($logLevel==2 && in_array($optType, array('insert', 'update'))){    
325.                  $isLog = true;    
326.              }    
327.              if ($logLevel==3 && in_array($optType, array('insert', 'update', 'delete'))){    
328.                  $isLog = true;    
329.              }    
330.              if ($logLevel==4 && in_array($optType, array('insert', 'update', 'delete', 'select'))){    
331.                  $isLog = true;    
332.              }    
333.              if ($isLog){    
334.                  $this->errorLog($sql);    
335.              }    
336.          }    
337.      
338.          //执行查询    
339.          $this->currConn = $dbConn;    
340.          $this->dbSql = $sql;    
341.          $this->dbResult = null;    
342.          $this->dbResult = @mysql_query($sql, $dbConn);    
343.          if ($this->dbResult === false){    
344.              $this->isError = true;    
345.              $this->errMsg  = 'MySQL errno:'. mysql_errno($dbConn) .', error:'. mysql_error($dbConn);    
346.              $this->errorLog("Query sql failed. SQL:".$sql, $dbConn);    
347.              if ($this->isExit) {    
348.                  exit;    
349.              }    
350.              return false;    
351.          }    
352.      
353.          $this->isError = false;    
354.          $this->errMsg  = '';    
355.      
356.          return true;    
357.      }    
358.      
359.      /**  
360.       * 错误日志  
361.       */    
362.      function errorLog($msg='', $conn=null){    
363.          if (!$this->isLog){    
364.              return;    
365.          }    
366.          if ($msg=='' && !$conn) {    
367.              return false;    
368.          }    
369.          $log = "MySQL Error: $msg";    
370.          if ($conn && is_resource($conn)) {    
371.              $log .= " mysql_msg:". mysql_error($conn);    
372.          }    
373.          $log .= " [". date("Y-m-d H:i:s") ."]";    
374.          if ($this->logFile != ''){    
375.              error_log($log ."/n", 3, $this->logFile);    
376.          } else {    
377.              error_log($log);    
378.          }    
379.          return true;    
380.      }    
381.      
382.      
383.      
384.      //--------------------------    
385.      //    
386.      //       数据获取接口    
387.      //    
388.      //--------------------------    
389.      /**  
390.       * 获取SQL执行的全部结果集(二维数组)  
391.       *  
392.       * @param string $sql 需要执行查询的SQL语句  
393.       * @return 成功返回查询结果的二维数组,失败返回false, 数据空返回NULL  
394.       */    
395.      function getAll($sql, $isMaster=false){    
396.          if (!$this->_query($sql, $isMaster)){    
397.              return false;    
398.          }    
399.          $this->dbRecord = array();    
400.          while ($row = @mysql_fetch_array($this->dbResult, $this->fetchMode)) {    
401.              $this->dbRecord[] = $row;    
402.          }    
403.          @mysql_free_result($this->dbResult);    
404.          if (!is_array($this->dbRecord) || emptyempty($this->dbRecord)){    
405.              return NULL;    
406.          }    
407.          return $this->dbRecord;    
408.      }    
409.      
410.      /**  
411.       * 获取单行记录(一维数组)  
412.       *  
413.       * @param string $sql 需要执行查询的SQL语句  
414.       * @return 成功返回结果记录的一维数组,失败返回false, 数据空返回NULL  
415.       */    
416.      function getRow($sql, $isMaster=false){    
417.          if (!$this->_query($sql, $isMaster)){    
418.              return false;    
419.          }    
420.          $this->dbRecord = array();    
421.          $this->dbRecord = @mysql_fetch_array($this->dbResult, $this->fetchMode);    
422.          @mysql_free_result($this->dbResult);    
423.          if (!is_array($this->dbRecord) || emptyempty($this->dbRecord)){    
424.              return NULL;    
425.          }    
426.          return $this->dbRecord;    
427.      }    
428.      
429.      /**  
430.       * 获取一列数据(一维数组)  
431.       *  
432.       * @param string $sql 需要获取的字符串  
433.       * @param string $field 需要获取的列,如果不指定,默认是第一列  
434.       * @return 成功返回提取的结果记录的一维数组,失败返回false, 数据空返回NULL  
435.       */    
436.      function getCol($sql, $field='', $isMaster=false){    
437.          if (!$this->_query($sql, $isMaster)){    
438.              return false;    
439.          }    
440.          $this->dbRecord = array();    
441.          while($row = @mysql_fetch_array($this->dbResult, $this->fetchMode)){    
442.              if (trim($field) == ''){    
443.                  $this->dbRecord[] = current($row);    
444.              } else {    
445.                  $this->dbRecord[] = $row[$field];    
446.              }    
447.          }    
448.          @mysql_free_result($this->dbResult);    
449.          if (!is_array($this->dbRecord) || emptyempty($this->dbRecord)){    
450.              return NULL;    
451.          }    
452.          return $this->dbRecord;    
453.      }    
454.      
455.      /**  
456.       * 获取一个数据(当条数组)  
457.       *  
458.       * @param string $sql 需要执行查询的SQL  
459.       * @return 成功返回获取的一个数据,失败返回false, 数据空返回NULL  
460.       */    
461.      function getOne($sql, $field='', $isMaster=false){    
462.          if (!$this->_query($sql, $isMaster)){    
463.              return false;    
464.          }    
465.          $this->dbRecord = array();    
466.          $row = @mysql_fetch_array($this->dbResult, $this->fetchMode);    
467.          @mysql_free_result($this->dbResult);    
468.          if (!is_array($row) || emptyempty($row)){    
469.              return NULL;    
470.          }    
471.          if (trim($field) != ''){    
472.              $this->dbRecord = $row[$field];    
473.          }else{    
474.              $this->dbRecord = current($row);    
475.          }    
476.          return $this->dbRecord;    
477.      }    
478.      
479.      
480.      
481.      /**  
482.       * 获取指定各种条件的记录  
483.       *  
484.       * @param string $table 表名(访问的数据表)  
485.       * @param string $field 字段(要获取的字段)  
486.       * @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)  
487.       * @param string $order 排序(按照什么字段排序,不包括ORDER BY,默认为空)  
488.       * @param string $limit 限制记录(需要提取多少记录,不包括LIMIT,默认为空)  
489.       * @param bool $single 是否只是取单条记录(是调用getRow还是getAll,默认是false,即调用getAll)  
490.       * @return 成功返回记录结果集的数组,失败返回false  
491.       */    
492.      function getRecord($table, $field='*', $where='', $order='', $limit='', $single=false, $isMaster=false){    
493.          $sql = "SELECT $field FROM $table";    
494.          $sql .= trim($where)!='' ? " WHERE $where " : $where;    
495.          $sql .= trim($order)!='' ? " ORDER BY $order " : $order;    
496.          $sql .= trim($limit)!='' ? " LIMIT $limit " : $limit;    
497.          if ($single){    
498.              return $this->getRow($sql, $isMaster);    
499.          }    
500.          return $this->getAll($sql, $isMaster);    
501.      }    
502.      
503.      /**  
504.       * 获取指点各种条件的记录(跟getRecored类似)  
505.       *  
506.       * @param string $table 表名(访问的数据表)  
507.       * @param string $field 字段(要获取的字段)  
508.       * @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)  
509.       * @param array $order_arr 排序数组(格式类似于: array('id'=>true), 那么就是按照ID为顺序排序, array('id'=>false), 就是按照ID逆序排序)  
510.       * @param array $limit_arr 提取数据的限制数组()  
511.       * @return unknown  
512.       */    
513.      function getRecordByWhere($table, $field='*', $where='', $arrOrder=array(), $arrLimit=array(), $isMaster=false){    
514.          $sql = " SELECT $field FROM $table ";    
515.          $sql .= trim($where)!='' ? " WHERE $where " : $where;    
516.          if (is_array($arrOrder) && !emptyempty($arrOrder)){    
517.              $arrKey = key($arrOrder);    
518.              $sql .= " ORDER BY $arrKey " . ($arrOrder[$arrKey] ? "ASC" : "DESC");    
519.          }    
520.          if (is_array($arrLimit) && !emptyempty($arrLimit)){    
521.              $startPos = intval(array_shift($arrLimit));    
522.              $offset = intval(array_shift($arrLimit));    
523.              $sql .= " LIMIT $startPos,$offset ";    
524.          }    
525.          return $this->getAll($sql, $isMaster);    
526.      }    
527.      
528.      /**  
529.       * 获取指定条数的记录  
530.       *  
531.       * @param string $table 表名  
532.       * @param int $startPos 开始记录  
533.       * @param int $offset 偏移量  
534.       * @param string $field 字段名  
535.       * @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)  
536.       * @param string $order 排序(按照什么字段排序,不包括ORDER BY,默认为空)  
537.       * @return 成功返回包含记录的二维数组,失败返回false  
538.       */    
539.      function getRecordByLimit($table, $startPos, $offset, $field='*', $where='', $oder='', $isMaster=false){    
540.          $sql = " SELECT $field FROM $table ";    
541.          $sql .= trim($where)!='' ? " WHERE $where " : $where;    
542.          $sql .= trim($order)!='' ? " ORDER BY $order " : $order;    
543.          $sql .= " LIMIT $startPos,$offset ";    
544.          return $this->getAll($sql, $isMaster);    
545.      }    
546.      
547.      /**  
548.       * 获取排序记录  
549.       *  
550.       * @param string $table 表名  
551.       * @param string $orderField 需要排序的字段(比如id)  
552.       * @param string $orderMethod 排序的方式(1为顺序, 2为逆序, 默认是1)  
553.       * @param string $field 需要提取的字段(默认是*,就是所有字段)  
554.       * @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)  
555.       * @param string $limit 限制记录(需要提取多少记录,不包括LIMIT,默认为空)  
556.       * @return 成功返回记录的二维数组,失败返回false  
557.       */    
558.      function getRecordByOrder($table, $orderField, $orderMethod=1, $field='*', $where='', $limit='', $isMaster=false){    
559.          //$order_method的值为1则为顺序, $order_method值为2则2则是逆序排列    
560.          $sql = " SELECT $field FROM $table ";    
561.          $sql .= trim($where)!='' ? " WHERE $where " : $where;    
562.          $sql .= " ORDER BY $orderField " . ( $orderMethod==1 ? "ASC" : "DESC");    
563.          $sql .= trim($limit)!='' ? " LIMIT $limit " : $limit;    
564.          return $this->getAll($sql, $isMaster);    
565.      }    
566.      
567.      /**  
568.       * 分页查询(限制查询的记录条数)  
569.       *  
570.       * @param string $sql 需要查询的SQL语句  
571.       * @param int $startPos 开始记录的条数  
572.       * @param int $offset 每次的偏移量,需要获取多少条  
573.       * @return 成功返回获取结果记录的二维数组,失败返回false  
574.       */    
575.      function limit_query($sql, $startPos, $offset, $isMaster=false){    
576.          $start_pos = intval($startPos);    
577.          $offset = intval($offset);    
578.          $sql = $sql . " LIMIT $startPos,$offset ";    
579.          return $this->getAll($sql, $isMaster);    
580.      }    
581.      
582.      
583.      //--------------------------    
584.      //    
585.      //     无数据返回操作接口    
586.      //    
587.      //--------------------------    
588.      /**  
589.       * 执行执行非Select查询操作  
590.       *  
591.       * @param string $sql 查询SQL语句  
592.       * @return bool  成功执行返回true, 失败返回false  
593.       */    
594.      function execute($sql, $isMaster=false){    
595.          if (!$this->_query($sql, $isMaster)){    
596.              return false;    
597.          }    
598.          return true;    
599.          /*$count = @mysql_affected_rows($this->dbLink);  
600.          if ($count <= 0){  
601.              return false;  
602.          }  
603.          return true;*/    
604.      }    
605.      
606.      /**  
607.       * 自动执行操作(针对Insert/Update操作)  
608.       *  
609.       * @param string $table 表名  
610.       * @param array $field_array 字段数组(数组中的键相当于字段名,数组值相当于值, 类似 array( 'id' => 100, 'user' => 'heiyeluren')  
611.       * @param int $mode 执行操作的模式 (是插入还是更新操作, 1是插入操作Insert, 2是更新操作Update)  
612.       * @param string $where 如果是更新操作,可以添加WHERE的条件  
613.       * @return bool 执行成功返回true, 失败返回false  
614.       */    
615.      function autoExecute($table, $arrField, $mode, $where='', $isMaster=false){    
616.          if ($table=='' || !is_array($arrField) || emptyempty($arrField)){    
617.              return false;    
618.          }    
619.          //$mode为1是插入操作(Insert), $mode为2是更新操作    
620.          if ($mode == 1){    
621.              $sql = " INSERT INTO `$table` SET ";    
622.          } elseif ($mode == 2) {    
623.              $sql = " UPDATE `$table` SET ";    
624.          } else {    
625.              $this->errorLog("Operate type '$mode' is error, in call DB::autoExecute process table $table.");    
626.              return false;    
627.          }    
628.          foreach ($arrField as $key => $value){    
629.              $sql .= "`$key`='$value',";    
630.          }    
631.          $sql = rtrim($sql, ',');    
632.          if ($mode==2 && $where!=''){    
633.              $sql .= "WHERE $where";    
634.          }    
635.          return $this->execute($sql, $isMaster);    
636.      }    
637.      
638.      /**  
639.       * 锁表表  
640.       *  
641.       * @param string $tblName 需要锁定表的名称  
642.       * @return mixed 成功返回执行结果，失败返回错误对象  
643.       */    
644.      function lockTable($tblName){    
645.          return $this->_query("LOCK TABLES $tblName", true);    
646.      }    
647.      
648.      /**  
649.       * 对锁定表进行解锁  
650.       *  
651.       * @param string $tblName 需要锁定表的名称  
652.       * @return mixed 成功返回执行结果，失败返回错误对象  
653.       */    
654.      function unlockTable($tblName){    
655.          return $this->_query("UNLOCK TABLES $tblName", true);    
656.      }    
657.      
658.      /**  
659.       * 设置自动提交模块的方式（针对InnoDB存储引擎）  
660.       * 一般如果是不需要使用事务模式，建议自动提交为1，这样能够提高InnoDB存储引擎的执行效率，如果是事务模式，那么就使用自动提交为0  
661.       *  
662.       * @param bool $autoCommit 如果是true则是自动提交，每次输入SQL之后都自动执行，缺省为false  
663.       * @return mixed 成功返回true，失败返回错误对象  
664.       */    
665.      function setAutoCommit($autoCommit = false){    
666.          $autoCommit = ( $autoCommit ? 1 : 0 );    
667.          return $this->_query("SET AUTOCOMMIT = $autoCommit", true);    
668.      }    
669.      
670.      /**  
671.       * 开始一个事务过程（针对InnoDB引擎，兼容使用 BEGIN 和 START TRANSACTION）  
672.       *  
673.       * @return mixed 成功返回true，失败返回错误对象  
674.       */    
675.      function startTransaction(){    
676.          if (!$this->_query("BEGIN")){    
677.              return $this->_query("START TRANSACTION", true);    
678.          }    
679.      }    
680.      
681.      /**  
682.       * 提交一个事务（针对InnoDB存储引擎）  
683.       *  
684.       * @return mixed 成功返回true，失败返回错误对象  
685.       */    
686.      function commit(){    
687.          if (!$this->_query("COMMIT", true)){    
688.              return false;    
689.          }    
690.          return $this->setAutoCommit( true );    
691.      }    
692.      
693.      /**  
694.       * 发生错误，会滚一个事务（针对InnoDB存储引擎）  
695.       *  
696.       * @return mixed 成功返回true，失败返回错误对象  
697.       */    
698.      
699.      function rollback(){    
700.          if (!$this->_query("ROLLBACK", true)){    
701.              return false;    
702.          }    
703.          return $this->setAutoCommit( true );    
704.      }    
705.      
706.      
707.      
708.      //--------------------------    
709.      //    
710.      //    其他数据操作接口    
711.      //    
712.      //--------------------------    
713.      
714.      /**  
715.       * 获取上次插入操作的的ID  
716.       *  
717.       * @return int 如果没有连接或者查询失败,返回0, 成功返回ID  
718.       */    
719.      function getLastId(){    
720.          $dbConn = $this->getDbWriteConn();    
721.          if (($lastId = mysql_insert_id($dbConn)) > 0){    
722.              return $lastId;    
723.          }    
724.          return $this->getOne("SELECT LAST_INSERT_ID()", '', true);    
725.      }    
726.      
727.      /**  
728.       * 获取记录集里面的记录条数 (用于Select操作)  
729.       *  
730.       * @return int 如果上一次无结果集或者记录结果集为空,返回0, 否则返回结果集数量  
731.       */    
732.      function getNumRows($res=null){    
733.          if (!$res || !is_resource($res)){    
734.              $res = $this->dbResult;    
735.          }    
736.          return mysql_num_rows($res);    
737.      }    
738.      
739.      /**  
740.       * 获取受到影响的记录数量 (用于Update/Delete/Insert操作)  
741.       *  
742.       * @return int 如果没有连接或者影响记录为空, 否则返回影响的行数量  
743.       */    
744.      function getAffectedRows(){    
745.          $dbConn = $this->getDbWriteConn();    
746.          if ( ($affetedRows = mysql_affected_rows($dbConn)) <= 0){    
747.              return $affetedRows;    
748.          }    
749.          return $this->getOne("SELECT ROW_COUNT()", "", true);            
750.      }    
751.      
752.      
753.      
754.      
755.      //--------------------------    
756.      //    
757.      //    监测开发调试接口    
758.      //    
759.      //--------------------------    
760.      
761.      /**  
762.       * 获取最后一次查询的SQL语句  
763.       *  
764.       * @return string 返回最后一次查询的SQL语句  
765.       */    
766.      function getLastSql(){    
767.          return $this->dbSql;    
768.      }    
769.      
770.      /**  
771.       * 返回SQL最后操作的数据库记录结果集  
772.       *  
773.       * @return mixed 最后结果集，可能是数组或者普通单个元素值  
774.       */    
775.      function getDBRecord(){    
776.          return $this->dbRecord;    
777.      }    
778.      
779.      /**  
780.       * 获取当前操作的数据库连接资源  
781.       *  
782.       * @return resouce 返回当前正在执行操作的数据库链接资源  
783.       */    
784.      function getCurrConnection(){    
785.          return $this->currConn;    
786.      }    
787.      
788.      /**  
789.       * SQL 执行是否出错  
790.       *   
791.       * @return bool   
792.       */    
793.      function isError(){    
794.          return $this->isError;    
795.      }    
796.      
797.      /**  
798.       * SQL 执行错误消息  
799.       *   
800.       * @return string  
801.       */    
802.      function getError(){    
803.          return $this->errMsg;    
804.      }    
805.      
806.      
807.      /**  
808.       * 输出所有类属性和SQL  
809.       *  
810.       * @param bool $format 使用哪种打印方式， false为 print_r, true为var_dump  
811.       * @return void  
812.       */    
813.      function p($format = false){    
814.          echo "<h3>DBCommon Debug info</h3> <br />/n";    
815.          echo "Execute SQL: <b>". $this->getLastSql() ."</b>  <br />/n";    
816.          echo "MySQL Error: <b>". $this->getError() ."</b>  <br />/n";    
817.          echo "<br />Other Attribute: <pre>/n";    
818.          $vars = get_object_vars($this);    
819.          if ($format){    
820.              var_dump($vars);    
821.          } else {    
822.              print_r($vars);             
823.          }    
824.          echo "</pre>/n<br /><br /><h5>Debug done.</h5>";    
825.      }    
826.          
827.      /**  
828.       * 输出所有类方法名  
829.       *   
830.       * @return void  
831.       */    
832.      function m()    
833.      {    
834.          $class = get_class($this);    
835.          $arr = get_class_methods($class);    
836.          echo "<h3>$class method list</h3><br />/n";    
837.          foreach ($arr as $method) {    
838.              echo "/t  $method() <br />/n";    
839.          }    
840.      }    
841.      
842.      /**  
843.       * 调试函数  
844.       *  
845.       * @param bool $format 使用哪种打印方式， false为 print_r, true为var_dump  
846.       * @return void  
847.       */    
848.      function debug($format = false, $printMethod = false){    
849.          $this->p($format);    
850.          if ($printMethod){    
851.              $this->m();    
852.          }    
853.      }    
854.      
855.      
856.      
857.      
858.      //--------------------------------    
859.      //    
860.      //    兼容 TMService 的简洁接口    
861.      //    
862.      //--------------------------------    
863.      
864.      /**  
865.       * 查询结果：二维数组返回  
866.       *   
867.       * @param string $sql 需要执行的SQL  
868.       * @return 成功返回获取的二维数组,失败返回false, 数据空返回NULL  
869.       */    
870.      function query($sql){    
871.          return $this->getAll($sql);    
872.      }    
873.      
874.      /**  
875.       * 插入数据  
876.       *  
877.       * @param array $field_array 字段数组(数组中的键相当于字段名,数组值相当于值, 类似 array( 'id' => 100, 'user' => 'heiyeluren')  
878.       * @param string $table 表名  
879.       * @return bool 执行成功返回true, 失败返回false  
880.       */    
881.      function insert($arrField, $table){    
882.          return $this->autoExecute($table, $arrField, 1);    
883.      }    
884.      
885.      /**  
886.       * 更新数据  
887.       *  
888.       * @param array $field_array 字段数组(数组中的键相当于字段名,数组值相当于值, 类似 array( 'id' => 100, 'user' => 'heiyeluren')  
889.       * @param string $table 表名  
890.       * @param string $where 如果是更新操作,可以添加WHERE的条件  
891.       * @return bool 执行成功返回true, 失败返回false  
892.       */    
893.      function update($arrField, $where, $table){    
894.          if (trim($where) == ''){    
895.              return false;    
896.          }    
897.          return $this->autoExecute($table, $arrField, 2, $where);    
898.      }    
899.      
900.      /**  
901.       * 获取某个表的Count  
902.       *   
903.       * @param array $arrField 需要处理的where条件的key，value  
904.       * @param string $table 需要获取的表名  
905.       * @return 成功返回获取的一个整数值,失败返回false, 数据空返回NULL  
906.       */    
907.      function getCount($arrField, $notFields, $table){    
908.          $sql = "SELECT COUNT(1) as cnt FROM ".$table." WHERE ";    
909.          foreach ($arrField as $key => $value){    
910.              $sql .= " `$key`='$value' AND ";    
911.          }    
912.          if (!emptyempty($notFields)){    
913.              foreach ($arrField as $key => $value){    
914.                  $sql .= " `$key`!='$value' AND ";    
915.              }    
916.          }    
917.          $sql .= " 1 ";    
918.          $row = $this->getOne($sql);    
919.          if ($row===NULL || $row===false){    
920.              return $row;    
921.          }    
922.          if (is_array($row)){    
923.              return (int)current($row);    
924.          }    
925.          return (int)$row;    
926.      }    
927.          
928.      
929.  }     

 

调用上面数据库操作对象：

view plainprint?

1. /**  
2.  * 工厂模式对象获取  
3.  *  
4.  */    
5. class common    
6. {    
7.     /**  
8.      * 数据库单例对象  
9.      */    
10.     public static $db = NULL;    
11.     
12.     /**  
13.      * 获取数据库对象  
14.      *  
15.      *  
16.      *  
17.       数据库使用示例和介绍：  
18.       $db = common::getDB();  
19.   
20.       //简洁接口  
21.       $db->query($sql);  //查询，二维数组 (兼容TM)  
22.       $db->insert($arr, $table); //插入数据 (兼容TM)  
23.       $db->update($arr, $where, $table); //更新数据 (兼容TM)  
24.       $db->getCount($arr, $notfield, $table); //获取数量 (兼容TM)  
25.   
26.       //基本数据操作接口  
27.       $db->getAll($sql); //读取所有数据，二维数组  
28.       $db->getRow($sql); //读取一行记录，一维数组  
29.       $db->getCol($sql); //读取一列记录，一维数组  
30.       $db->getOne($sql); //获取单个单元值  
31.       $db->execute($sql); //纯执行SQL，返回true或false  
32.       $db->getNumRows(); //获取上一次select操作记录结果集总数  
33.       $db->getAffectedRows(); //获取上个操作影响的行数  
34.   
35.       //方便开发调试接口  
36.       $db->debug();  //打印调试信息  
37.       $db->isError(); //SQL是否执行错误，true为有错误，false为没有错误  
38.       $db->getError(); //SQL执行错误消息  
39.       $db->getLastSql(); //获取最后一条执行的SQL  
40.       $db->getCurrConnection(); //获取当前数据库连接，方便直接自主操作MySQL  
41.      */    
42.     public static function getDB(){    
43.         if (is_object(self::$db)){    
44.             return self::$db;    
45.         }    
46.         $cryption = new TMCryption();    
47.         $config = array(    
48.             "host"  => 'localhost',    
49.             "user"  => 'root',    
50.             "pwd"   => '',    
51.             "db"    => 'test',    
52.         );    
53.         self::$db = new DBCommon($config, array(), true);    
54.         self::$db->set('isCharset', false);    
55.         self::$db->query("SET NAMES utf8");    
56.     
57.         return self::$db;    
58.     }