數據庫操作類

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

數據庫操作類：DBCommon.class.php

 //---------------------------------------------------------------------
 //      MySQL Master/Slave數據庫讀寫操作類
 //
 // 開發作者: heiyeluren
 // 版本歷史:
 //          2006-09-20  基本單數據庫操作功能, 25 個接口
 //          2007-07-30  支持單Master/多Slave數據庫操作，29個接口
 //          2008-09-07  修正了上一版本的部分Bug
 //          2009-11-17  在Master/Slave類的基礎上增加了強化單主機操作，
 //                  增加了部分簡潔操作接口和調試接口，優化了部分代碼，
 //                  本版本共42個接口
 // 應用項目: Y!NCP, Y!SNS, TM MiniSite//
 // 功能描述：自動支持Master/Slave 讀/寫 分離操作，支持多Slave主機
 //
 //-----------------------------------------------------------------------



 /**
  * 常量定義
  */
 define("_DB_INSERT", 1);
 define("_DB_UPDATE", 2);


 /**
  * DB Common class
  *
  * 描述：能夠分別處理一臺Master寫操作，多臺Slave讀操作
  */
 class DBCommon
 {
     /**
      * 數據庫配置信息
      */
     var $wdbConf = array();
     var $rdbConf = array();
     /**
      * Master數據庫連接
      */
     var $wdbConn = null;
     /**
      * Slave數據庫連接
      */
     var $rdbConn = array();
     /**
      * 當前操作的數據庫鏈接
      */
     var $currConn = null;
     /**
      * 是否只有一臺Master數據庫服務器
      */
     var $singleHost = true;
     /**
      * 數據庫結果
      */
     var $dbResult;
     /**
      * 數據庫查詢結果集
      */
     var $dbRecord;

     /**
      * SQL語句
      */
     var $dbSql;
     /**
      * 數據庫編碼
      */
     var $dbCharset = "UTF8";
     /**
      * 數據庫版本
      */
     var $dbVersion = "5.0";


     /**
      * 初始化的時候是否要連接到數據庫
      */
     var $isInitConn = false;
     /**
      * 是否要設置字符集
      */
     var $isCharset = false;
     /**
      * 數據庫結果集提取方式
      */
     var $fetchMode = MYSQL_ASSOC;
     /**
      * 執行中發生錯誤是否記錄日誌
      */
     var $isLog = false;
     /**
      * 執行中的SQL是否記錄，設定級別
      *
      * 0:不記錄
      * 1:記錄insert
      * 2:記錄insert/update
      * 3:記錄insert/update/delete
      * 4:記錄select/insert/update/delete
      */
     var $logSqlLevel = 0;
     /**
      * 記錄Log文件路徑
      */
     var $logFile = '/tmp/db_common_error.log';
     /**
      * 是否查詢出錯的時候終止腳本執行
      */
     var $isExit = false;
     /**
      * MySQL執行是否出錯了
      */
     var $isError = false;
     /**
      * MySQL執行錯誤消息
      */
     var $errMsg  = '';



     //------------------------
     //
     //  類本身操作方法
     //
     //------------------------

     /**
      * 設置類屬性
      *
      * @param str $key  需要設置的屬性名
      * @param str $value 需要設置的屬性值
      * @return void
      */
     function set($key, $value){
         $this->$key = $value;
     }

     /**
      * 讀取類屬性
      *
      * @param str $key  需要讀取的屬性名
      * @return void
      */
     function get($key){
         return $this->$key;
     }




     //------------------------
     //
     //   基礎底層操作接口
     //
     //------------------------

     /**
      * 構造函數
      *
      * 傳遞配置信息，配置信息數組結構：
      * $masterConf = array(
      *        "host"    => Master數據庫主機地址
      *        "user"    => 登錄用戶名
      *        "pwd"    => 登錄密碼
      *        "db"    => 默認連接的數據庫
      *    );
      * $slaveConf = array(
      *        "host"    => Slave1數據庫主機地址|Slave2數據庫主機地址|...
      *        "user"    => 登錄用戶名
      *        "pwd"    => 登錄密碼
      *        "db"    => 默認連接的數據庫
      *    );
      *
      * @param bool $singleHost  是否只有一臺主機
      * @return void
      */
     function DBCommon($masterConf, $slaveConf=array(), $singleHost = true){
         //構造數據庫配置信息
         if (is_array($masterConf) && !emptyempty($masterConf)){
             $this->wdbConf = $masterConf;
         }
         if (!is_array($slaveConf) || emptyempty($slaveConf)){
             $this->rdbConf = $masterConf;
         } else {
             $this->rdbConf = $slaveConf;
         }
         $this->singleHost = $singleHost;
         //初始化連接（一般不推薦）
         if ($this->isInitConn){
             $this->getDbWriteConn();
if (!$this->singleHost){ $this->getDbReadConn(); } } } /** *
獲取Master的寫數據連接 */ function getDbWriteConn(){ //判斷是否已經連接 if
($this->wdbConn && is_resource($this->wdbConn)) { return
$this->wdbConn; } //沒有連接則自行處理 $db =
$this->connect($this->wdbConf['host'], $this->wdbConf['user'],
$this->wdbConf['pwd'], $this->wdbConf['db']); if (!$db ||
!is_resource($db)) { return false; } $this->wdbConn = $db; return
$this->wdbConn; } /** * 獲取Slave的讀數據連接 */ function getDbReadConn(){
//如果有可用的Slave連接，隨機挑選一臺Slave if (is_array($this->rdbConn) &&
!emptyempty($this->rdbConn)) { $key = array_rand($this->rdbConn);
if (isset($this->rdbConn[$key]) &&
is_resource($this->rdbConn[$key])) { return $this->rdbConn[$key];
} } //連接到所有Slave數據庫，如果沒有可用的Slave機則調用Master $arrHost = explode("|",
$this->rdbConf['host']); if (!is_array($arrHost) ||
emptyempty($arrHost)){ return $this->getDbWriteConn(); }
$this->rdbConn = array(); foreach($arrHost as $tmpHost){ $db =
$this->connect($tmpHost, $this->rdbConf['user'],
$this->rdbConf['pwd'], $this->rdbConf['db']); if ($db &&
is_resource($db)){ $this->rdbConn[] = $db; } }
//如果沒有一臺可用的Slave則調用Master if (!is_array($this->rdbConn) ||
emptyempty($this->rdbConn)){ $this->errorLog("Not availability
slave db connection, call master db connection"); return
$this->getDbWriteConn(); } //隨機在已連接的Slave機中選擇一臺 $key =
array_rand($this->rdbConn); if (isset($this->rdbConn[$key])
&& is_resource($this->rdbConn[$key])){ return
$this->rdbConn[$key]; }
//如果選擇的slave機器是無效的，並且可用的slave機器大於一臺則循環遍歷所有能用的slave機器 if
(count($this->rdbConn) > 1){ foreach($this->rdbConn as $conn){
if (is_resource($conn)){ return $conn; } } }
//如果沒有可用的Slave連接，則繼續使用Master連接 return $this->getDbWriteConn(); } /**
* 連接到MySQL數據庫公共方法 */ function connect($dbHost, $dbUser, $dbPasswd,
$dbDatabase){ //連接數據庫主機 $db = mysql_connect($dbHost, $dbUser,
$dbPasswd); if (!$db) { $this->errorLog("Mysql connect ". $dbHost ."
failed"); return false; } //選定數據庫 if (!mysql_select_db($dbDatabase,
$db)) { $this->errorLog("select db $dbDatabase failed", $db); return
false; } //設置字符集 if ($this->isCharset){ if ( $this->dbVersion ==
'' ){ $res = mysql_query("SELECT VERSION()"); $this->dbVersion =
mysql_result($res, 0); } if ($this->dbCharset!='' &&
preg_match("/^(5.|4.1)/", $this->dbVersion)){ if (mysql_query("SET
NAMES '".$this->dbCharset."'", $db) === false){
$this->errorLog("Set db_host '$dbHost' charset=".
$this->dbCharset ." failed.", $db); return false; } } } return $db;
} /** * 關閉數據庫連接 */ function disconnect($dbConn=null, $closeAll=false){
//關閉指定數據庫連接 if ($dbConn && is_resource($dbConn)){
mysql_close($dbConn); $dbConn = null; } //關閉所有數據庫連接 if ($closeAll){ if
($this->rdbConn && is_resource($this->rdbConn)){
mysql_close($this->rdbConn); $this->rdbConn = null;
             }
             if (is_array($this->rdbConn) && !emptyempty($this->rdbConn)){
                 foreach($this->rdbConn as $conn){
                     if ($conn && is_resource($conn)){
                         mysql_close($conn);
                     }
                 }
                 $this->rdbConn = array();
             }
         }
         return true;
     }

     /**
      * 選擇數據庫
      */
     function selectDb($dbName, $dbConn=null){
         //重新選擇一個連接的數據庫
         if ($dbConn && is_resource($dbConn)){
             if (!mysql_select_db($dbName, $dbConn)){
                 $this->errorLog("Select database:$dbName failed.", $dbConn);
                 return false;
             }
             return true;
         }
         //重新選擇所有連接的數據庫
         if ($this->wdbConn && is_resource($this->wdbConn)){
             if (!mysql_select_db($dbName, $this->wdbConn)){
                 $this->errorLog("Select database:$dbName failed.", $this->wdbConn);
                 return false;
             }
         }
         if (is_array($this->rdbConn && !emptyempty($this->rdbConn))){
             foreach($this->rdbConn as $conn){
                 if ($conn && is_resource($conn)){
                     if (!mysql_select_db($dbName, $conn)){
                         $this->errorLog("Select database:$dbName failed.", $conn);
                         return false;
                     }
                 }
             }
         }
         return true;
     }

     /**
      * 執行SQL語句（底層操作）
      */
     function _query($sql, $isMaster=false){
         if (trim($sql) == ""){
             $this->errorLog("Sql query is empty.");
             return false;
         }
         //是否只有一臺數據庫機器
         if ($this->singleHost){
             $isMaster = true;
         }

         //獲取執行SQL的數據庫連接
         if (!$isMaster){
             $optType = trim(strtolower(substr(ltrim($sql), 0, 6)));
         }
         if ($isMaster || $optType!="select"){
             $dbConn = $this->getDbWriteConn();
         } else {
             $dbConn = $this->getDbReadConn();
         }
         if (!$dbConn || !is_resource($dbConn)){
             $this->isError = true;
             $this->errMsg  = 'Not availability db connection.';
             $this->currConn = null;

             $this->errorLog("Not availability db connection. Query SQL:". $sql);
             if ($this->isExit) {
                 exit;
             }
             return false;
         }
         //記錄執行的SQL
         if ($this->logSqlLevel){
             $isLog = false;
             $logLevel = $this->logSqlLevel;
             if ($logLevel==1 && in_array($optType, array('insert'))){
                 $isLog = true;
             }
             if ($logLevel==2 && in_array($optType, array('insert', 'update'))){
                 $isLog = true;
             }
             if ($logLevel==3 && in_array($optType, array('insert', 'update', 'delete'))){
                 $isLog = true;
             }
             if ($logLevel==4 && in_array($optType, array('insert', 'update', 'delete', 'select'))){
                 $isLog = true;
             }
             if ($isLog){
                 $this->errorLog($sql);
             }
         }

         //執行查詢
         $this->currConn = $dbConn;
         $this->dbSql = $sql;
         $this->dbResult = null;
         $this->dbResult = @mysql_query($sql, $dbConn);
         if ($this->dbResult === false){
             $this->isError = true;
             $this->errMsg  = 'MySQL errno:'. mysql_errno($dbConn) .', error:'. mysql_error($dbConn);
             $this->errorLog("Query sql failed. SQL:".$sql, $dbConn);
             if ($this->isExit) {
                 exit;
             }
             return false;
         }

         $this->isError = false;
         $this->errMsg  = '';

         return true;
     }

     /**
      * 錯誤日誌
      */
     function errorLog($msg='', $conn=null){
         if (!$this->isLog){
             return;
         }
         if ($msg=='' && !$conn) {
             return false;
         }
         $log = "MySQL Error: $msg";
         if ($conn && is_resource($conn)) {
             $log .= " mysql_msg:". mysql_error($conn);
         }
         $log .= " [". date("Y-m-d H:i:s") ."]";
         if ($this->logFile != ''){
             error_log($log ."/n", 3, $this->logFile);
         } else {
             error_log($log);
         }
         return true;
     }



     //--------------------------
     //
     //       數據獲取接口
     //
     //--------------------------
     /**
      * 獲取SQL執行的全部結果集(二維數組)
      *
      * @param string $sql 需要執行查詢的SQL語句
      * @return 成功返回查詢結果的二維數組,失敗返回false, 數據空返回NULL
      */
     function getAll($sql, $isMaster=false){
         if (!$this->_query($sql, $isMaster)){
             return false;
         }
         $this->dbRecord = array();
         while ($row = @mysql_fetch_array($this->dbResult, $this->fetchMode)) {
             $this->dbRecord[] = $row;
         }
         @mysql_free_result($this->dbResult);
         if (!is_array($this->dbRecord) || emptyempty($this->dbRecord)){
             return NULL;
         }
         return $this->dbRecord;
     }

     /**
      * 獲取單行記錄(一維數組)
      *
      * @param string $sql 需要執行查詢的SQL語句
      * @return 成功返回結果記錄的一維數組,失敗返回false, 數據空返回NULL
      */
     function getRow($sql, $isMaster=false){
         if (!$this->_query($sql, $isMaster)){
             return false;
         }
         $this->dbRecord = array();
         $this->dbRecord = @mysql_fetch_array($this->dbResult, $this->fetchMode);
         @mysql_free_result($this->dbResult);
         if (!is_array($this->dbRecord) || emptyempty($this->dbRecord)){
             return NULL;
         }
         return $this->dbRecord;
     }

     /**
      * 獲取一列數據(一維數組)
      *
      * @param string $sql 需要獲取的字符串
      * @param string $field 需要獲取的列,如果不指定,默認是第一列
      * @return 成功返回提取的結果記錄的一維數組,失敗返回false, 數據空返回NULL
      */
     function getCol($sql, $field='', $isMaster=false){
         if (!$this->_query($sql, $isMaster)){
             return false;
         }
         $this->dbRecord = array();
         while($row = @mysql_fetch_array($this->dbResult, $this->fetchMode)){
             if (trim($field) == ''){
                 $this->dbRecord[] = current($row);
             } else {
                 $this->dbRecord[] = $row[$field];
             }
         }
         @mysql_free_result($this->dbResult);
         if (!is_array($this->dbRecord) || emptyempty($this->dbRecord)){
             return NULL;
         }
         return $this->dbRecord;
     }

     /**
      * 獲取一個數據(當條數組)
      *
      * @param string $sql 需要執行查詢的SQL
      * @return 成功返回獲取的一個數據,失敗返回false, 數據空返回NULL
      */
     function getOne($sql, $field='', $isMaster=false){
         if (!$this->_query($sql, $isMaster)){
             return false;
         }
         $this->dbRecord = array();
         $row = @mysql_fetch_array($this->dbResult, $this->fetchMode);
         @mysql_free_result($this->dbResult);
         if (!is_array($row) || emptyempty($row)){
             return NULL;
         }
         if (trim($field) != ''){
             $this->dbRecord = $row[$field];
         }else{
             $this->dbRecord = current($row);
         }
         return $this->dbRecord;
     }



     /**
      * 獲取指定各種條件的記錄
      *
      * @param string $table 表名(訪問的數據表)
      * @param string $field 字段(要獲取的字段)
      * @param string $where 條件(獲取記錄的條件語句,不包括WHERE,默認爲空)
      * @param string $order 排序(按照什麼字段排序,不包括ORDER BY,默認爲空)
      * @param string $limit 限制記錄(需要提取多少記錄,不包括LIMIT,默認爲空)
      * @param bool $single 是否只是取單條記錄(是調用getRow還是getAll,默認是false,即調用getAll)
      * @return 成功返回記錄結果集的數組,失敗返回false
      */
     function getRecord($table, $field='*', $where='', $order='', $limit='', $single=false, $isMaster=false){
         $sql = "SELECT $field FROM $table";
         $sql .= trim($where)!='' ? " WHERE $where " : $where;
         $sql .= trim($order)!='' ? " ORDER BY $order " : $order;
         $sql .= trim($limit)!='' ? " LIMIT $limit " : $limit;
         if ($single){
             return $this->getRow($sql, $isMaster);
         }
         return $this->getAll($sql, $isMaster);
     }

     /**
      * 獲取指點各種條件的記錄(跟getRecored類似)
      *
      * @param string $table 表名(訪問的數據表)
      * @param string $field 字段(要獲取的字段)
      * @param string $where 條件(獲取記錄的條件語句,不包括WHERE,默認爲空)
      * @param array $order_arr 排序數組(格式類似於: array('id'=>true), 那麼就是按照ID爲順序排序, array('id'=>false), 就是按照ID逆序排序)
      * @param array $limit_arr 提取數據的限制數組()
      * @return unknown
      */
     function getRecordByWhere($table, $field='*', $where='', $arrOrder=array(), $arrLimit=array(), $isMaster=false){
         $sql = " SELECT $field FROM $table ";
         $sql .= trim($where)!='' ? " WHERE $where " : $where;
         if (is_array($arrOrder) && !emptyempty($arrOrder)){
             $arrKey = key($arrOrder);
             $sql .= " ORDER BY $arrKey " . ($arrOrder[$arrKey] ? "ASC" : "DESC");
         }
         if (is_array($arrLimit) && !emptyempty($arrLimit)){
             $startPos = intval(array_shift($arrLimit));
             $offset = intval(array_shift($arrLimit));
             $sql .= " LIMIT $startPos,$offset ";
         }
         return $this->getAll($sql, $isMaster);
     }

     /**
      * 獲取指定條數的記錄
      *
      * @param string $table 表名
      * @param int $startPos 開始記錄
      * @param int $offset 偏移量
      * @param string $field 字段名
      * @param string $where 條件(獲取記錄的條件語句,不包括WHERE,默認爲空)
      * @param string $order 排序(按照什麼字段排序,不包括ORDER BY,默認爲空)
      * @return 成功返回包含記錄的二維數組,失敗返回false
      */
     function getRecordByLimit($table, $startPos, $offset, $field='*', $where='', $oder='', $isMaster=false){
         $sql = " SELECT $field FROM $table ";
         $sql .= trim($where)!='' ? " WHERE $where " : $where;
         $sql .= trim($order)!='' ? " ORDER BY $order " : $order;
         $sql .= " LIMIT $startPos,$offset ";
         return $this->getAll($sql, $isMaster);
     }

     /**
      * 獲取排序記錄
      *
      * @param string $table 表名
      * @param string $orderField 需要排序的字段(比如id)
      * @param string $orderMethod 排序的方式(1爲順序, 2爲逆序, 默認是1)
      * @param string $field 需要提取的字段(默認是*,就是所有字段)
      * @param string $where 條件(獲取記錄的條件語句,不包括WHERE,默認爲空)
      * @param string $limit 限制記錄(需要提取多少記錄,不包括LIMIT,默認爲空)
      * @return 成功返回記錄的二維數組,失敗返回false
      */
     function getRecordByOrder($table, $orderField, $orderMethod=1, $field='*', $where='', $limit='', $isMaster=false){
         //$order_method的值爲1則爲順序, $order_method值爲2則2則是逆序排列
         $sql = " SELECT $field FROM $table ";
         $sql .= trim($where)!='' ? " WHERE $where " : $where;
         $sql .= " ORDER BY $orderField " . ( $orderMethod==1 ? "ASC" : "DESC");
         $sql .= trim($limit)!='' ? " LIMIT $limit " : $limit;
         return $this->getAll($sql, $isMaster);
     }

     /**
      * 分頁查詢(限制查詢的記錄條數)
      *
      * @param string $sql 需要查詢的SQL語句
      * @param int $startPos 開始記錄的條數
      * @param int $offset 每次的偏移量,需要獲取多少條
      * @return 成功返回獲取結果記錄的二維數組,失敗返回false
      */
     function limit_query($sql, $startPos, $offset, $isMaster=false){
         $start_pos = intval($startPos);
         $offset = intval($offset);
         $sql = $sql . " LIMIT $startPos,$offset ";
         return $this->getAll($sql, $isMaster);
     }


     //--------------------------
     //
     //     無數據返回操作接口
     //
     //--------------------------
     /**
      * 執行執行非Select查詢操作
      *
      * @param string $sql 查詢SQL語句
      * @return bool  成功執行返回true, 失敗返回false
      */
     function execute($sql, $isMaster=false){
         if (!$this->_query($sql, $isMaster)){
             return false;
         }
         return true;
         /*$count = @mysql_affected_rows($this->dbLink);
         if ($count <= 0){
             return false;
         }
         return true;*/
     }

     /**
      * 自動執行操作(針對Insert/Update操作)
      *
      * @param string $table 表名
      * @param array $field_array 字段數組(數組中的鍵相當於字段名,數組值相當於值, 類似 array( 'id' => 100, 'user' => 'heiyeluren')
      * @param int $mode 執行操作的模式 (是插入還是更新操作, 1是插入操作Insert, 2是更新操作Update)
      * @param string $where 如果是更新操作,可以添加WHERE的條件
      * @return bool 執行成功返回true, 失敗返回false
      */
     function autoExecute($table, $arrField, $mode, $where='', $isMaster=false){
         if ($table=='' || !is_array($arrField) || emptyempty($arrField)){
             return false;
         }
         //$mode爲1是插入操作(Insert), $mode爲2是更新操作
         if ($mode == 1){
             $sql = " INSERT INTO `$table` SET ";
         } elseif ($mode == 2) {
             $sql = " UPDATE `$table` SET ";
         } else {
             $this->errorLog("Operate type '$mode' is error, in call DB::autoExecute process table $table.");
             return false;
         }
         foreach ($arrField as $key => $value){
             $sql .= "`$key`='$value',";
         }
         $sql = rtrim($sql, ',');
         if ($mode==2 && $where!=''){
             $sql .= "WHERE $where";
         }
         return $this->execute($sql, $isMaster);
     }

     /**
      * 鎖表表
      *
      * @param string $tblName 需要鎖定表的名稱
      * @return mixed 成功返回執行結果，失敗返回錯誤對象
      */
     function lockTable($tblName){
         return $this->_query("LOCK TABLES $tblName", true);
     }

     /**
      * 對鎖定表進行解鎖
      *
      * @param string $tblName 需要鎖定表的名稱
      * @return mixed 成功返回執行結果，失敗返回錯誤對象
      */
     function unlockTable($tblName){
         return $this->_query("UNLOCK TABLES $tblName", true);
     }

     /**
      * 設置自動提交模塊的方式（針對InnoDB存儲引擎）
      * 一般如果是不需要使用事務模式，建議自動提交爲1，這樣能夠提高InnoDB存儲引擎的執行效率，如果是事務模式，那麼就使用自動提交爲0
      *
      * @param bool $autoCommit 如果是true則是自動提交，每次輸入SQL之後都自動執行，缺省爲false
      * @return mixed 成功返回true，失敗返回錯誤對象
      */
     function setAutoCommit($autoCommit = false){
         $autoCommit = ( $autoCommit ? 1 : 0 );
         return $this->_query("SET AUTOCOMMIT = $autoCommit", true);
     }

     /**
      * 開始一個事務過程（針對InnoDB引擎，兼容使用 BEGIN 和 START TRANSACTION）
      *
      * @return mixed 成功返回true，失敗返回錯誤對象
      */
     function startTransaction(){
         if (!$this->_query("BEGIN")){
             return $this->_query("START TRANSACTION", true);
         }
     }

     /**
      * 提交一個事務（針對InnoDB存儲引擎）
      *
      * @return mixed 成功返回true，失敗返回錯誤對象
      */
     function commit(){
         if (!$this->_query("COMMIT", true)){
             return false;
         }
         return $this->setAutoCommit( true );
     }

     /**
      * 發生錯誤，會滾一個事務（針對InnoDB存儲引擎）
      *
      * @return mixed 成功返回true，失敗返回錯誤對象
      */

     function rollback(){
         if (!$this->_query("ROLLBACK", true)){
             return false;
         }
         return $this->setAutoCommit( true );
     }



     //--------------------------
     //
     //    其他數據操作接口
     //
     //--------------------------

     /**
      * 獲取上次插入操作的的ID
      *
      * @return int 如果沒有連接或者查詢失敗,返回0, 成功返回ID
      */
     function getLastId(){
         $dbConn = $this->getDbWriteConn();
         if (($lastId = mysql_insert_id($dbConn)) > 0){
             return $lastId;
         }
         return $this->getOne("SELECT LAST_INSERT_ID()", '', true);
     }

     /**
      * 獲取記錄集裏面的記錄條數 (用於Select操作)
      *
      * @return int 如果上一次無結果集或者記錄結果集爲空,返回0, 否則返回結果集數量
      */
     function getNumRows($res=null){
         if (!$res || !is_resource($res)){
             $res = $this->dbResult;
         }
         return mysql_num_rows($res);
     }

     /**
      * 獲取受到影響的記錄數量 (用於Update/Delete/Insert操作)
      *
      * @return int 如果沒有連接或者影響記錄爲空, 否則返回影響的行數量
      */
     function getAffectedRows(){
         $dbConn = $this->getDbWriteConn();
         if ( ($affetedRows = mysql_affected_rows($dbConn)) <= 0){
             return $affetedRows;
         }
         return $this->getOne("SELECT ROW_COUNT()", "", true);
     }




     //--------------------------
     //
     //    監測開發調試接口
     //
     //--------------------------

     /**
      * 獲取最後一次查詢的SQL語句
      *
      * @return string 返回最後一次查詢的SQL語句
      */
     function getLastSql(){
         return $this->dbSql;
     }

     /**
      * 返回SQL最後操作的數據庫記錄結果集
      *
      * @return mixed 最後結果集，可能是數組或者普通單個元素值
      */
     function getDBRecord(){
         return $this->dbRecord;
     }

     /**
      * 獲取當前操作的數據庫連接資源
      *
      * @return resouce 返回當前正在執行操作的數據庫鏈接資源
      */
     function getCurrConnection(){
         return $this->currConn;
     }

     /**
      * SQL 執行是否出錯
      *
      * @return bool
      */
     function isError(){
         return $this->isError;
     }

     /**
      * SQL 執行錯誤消息
      *
      * @return string
      */
     function getError(){
         return $this->errMsg;
     }


     /**
      * 輸出所有類屬性和SQL
      *
      * @param bool $format 使用哪種打印方式， false爲 print_r, true爲var_dump
      * @return void
      */
     function p($format = false){
         echo "<h3>DBCommon Debug info</h3> <br />/n";
         echo "Execute SQL: <b>". $this->getLastSql() ."</b>  <br />/n";
         echo "MySQL Error: <b>". $this->getError() ."</b>  <br />/n";
         echo "<br />Other Attribute: <pre>/n";
         $vars = get_object_vars($this);
         if ($format){
             var_dump($vars);
         } else {
             print_r($vars);
         }
         echo "</pre>/n<br /><br /><h5>Debug done.</h5>";
     }

     /**
      * 輸出所有類方法名
      *
      * @return void
      */
     function m()
     {
         $class = get_class($this);
         $arr = get_class_methods($class);
         echo "<h3>$class method list</h3><br />/n";
         foreach ($arr as $method) {
             echo "/t  $method() <br />/n";
         }
     }

     /**
      * 調試函數
      *
      * @param bool $format 使用哪種打印方式， false爲 print_r, true爲var_dump
      * @return void
      */
     function debug($format = false, $printMethod = false){
         $this->p($format);
         if ($printMethod){
             $this->m();
         }
     }




     //--------------------------------
     //
     //    兼容 TMService 的簡潔接口
     //
     //--------------------------------

     /**
      * 查詢結果：二維數組返回
      *
      * @param string $sql 需要執行的SQL
      * @return 成功返回獲取的二維數組,失敗返回false, 數據空返回NULL
      */
     function query($sql){
         return $this->getAll($sql);
     }

     /**
      * 插入數據
      *
      * @param array $field_array 字段數組(數組中的鍵相當於字段名,數組值相當於值, 類似 array( 'id' => 100, 'user' => 'heiyeluren')
      * @param string $table 表名
      * @return bool 執行成功返回true, 失敗返回false
      */
     function insert($arrField, $table){
         return $this->autoExecute($table, $arrField, 1);
     }

     /**
      * 更新數據
      *
      * @param array $field_array 字段數組(數組中的鍵相當於字段名,數組值相當於值, 類似 array( 'id' => 100, 'user' => 'heiyeluren')
      * @param string $table 表名
      * @param string $where 如果是更新操作,可以添加WHERE的條件
      * @return bool 執行成功返回true, 失敗返回false
      */
     function update($arrField, $where, $table){
         if (trim($where) == ''){
             return false;
         }
         return $this->autoExecute($table, $arrField, 2, $where);
     }

     /**
      * 獲取某個表的Count
      *
      * @param array $arrField 需要處理的where條件的key，value
      * @param string $table 需要獲取的表名
      * @return 成功返回獲取的一個整數值,失敗返回false, 數據空返回NULL
      */
     function getCount($arrField, $notFields, $table){
         $sql = "SELECT COUNT(1) as cnt FROM ".$table." WHERE ";
         foreach ($arrField as $key => $value){
             $sql .= " `$key`='$value' AND ";
         }
         if (!emptyempty($notFields)){
             foreach ($arrField as $key => $value){
                 $sql .= " `$key`!='$value' AND ";
             }
         }
         $sql .= " 1 ";
         $row = $this->getOne($sql);
         if ($row===NULL || $row===false){
             return $row;
         }
         if (is_array($row)){
             return (int)current($row);
         }
         return (int)$row;
     }


 }

 

調用上面數據庫操作對象：

/**
 * 工廠模式對象獲取
 *
 */
class common
{
    /**
     * 數據庫單例對象
     */
    public static $db = NULL;

    /**
     * 獲取數據庫對象
     *
     *
     *
      數據庫使用示例和介紹：
      $db = common::getDB();

      //簡潔接口
      $db->query($sql);  //查詢，二維數組 (兼容TM)
      $db->insert($arr, $table); //插入數據 (兼容TM)
      $db->update($arr, $where, $table); //更新數據 (兼容TM)
      $db->getCount($arr, $notfield, $table); //獲取數量 (兼容TM)

      //基本數據操作接口
      $db->getAll($sql); //讀取所有數據，二維數組
      $db->getRow($sql); //讀取一行記錄，一維數組
      $db->getCol($sql); //讀取一列記錄，一維數組
      $db->getOne($sql); //獲取單個單元值
      $db->execute($sql); //純執行SQL，返回true或false
      $db->getNumRows(); //獲取上一次select操作記錄結果集總數
      $db->getAffectedRows(); //獲取上個操作影響的行數

      //方便開發調試接口
      $db->debug();  //打印調試信息
      $db->isError(); //SQL是否執行錯誤，true爲有錯誤，false爲沒有錯誤
      $db->getError(); //SQL執行錯誤消息
      $db->getLastSql(); //獲取最後一條執行的SQL
      $db->getCurrConnection(); //獲取當前數據庫連接，方便直接自主操作MySQL
     */
    public static function getDB(){
        if (is_object(self::$db)){
            return self::$db;
        }
        $cryption = new TMCryption();
        $config = array(
            "host"  => 'localhost',
            "user"  => 'root',
            "pwd"   => '',
            "db"    => 'test',
        );
        self::$db = new DBCommon($config, array(), true);
        self::$db->set('isCharset', false);
        self::$db->query("SET NAMES utf8");

        return self::$db;
    }