一个mysql数据库访问类,带简单的数据缓存功能

本数据访问类是之前自己写的一个框架里的,修改了一下,所以先放在博客里

下载:

db.rar

主要几个功能

第一个是数据统计
count($table,$where=”,$order=”,$group=”);

第二个是查找第一条数据
find($table,$where=”,$field=’*’,$order=”,$limit=”,$group=”)

第三个是查找一组数据
findAll($table,$where=”,$field=’*’,$order=”,$limit=”,$group=”)

第四个是全文件检索,需mysql类型的词库一份,本博里有,如有需要请在博客里搜索全文检索
fullText($table,$key,$str,$where=”,$field=’*’,$limit=”,$group=”)

第五个是数据的缓存,目前只支持find findAll两种方法
dbCache($time,$func,$table,$where=”,$field=’*’,$order=”,$limit=”,$group=”)

第六个是插入数据,只需指定表名和要插入的数组即可,可以直接用$_POST 会自动寻找与表字段相匹配的数据进入插入,插入的数据自己做防注入处理
insert($table,$data)

第七个是删除数据,只需指定表名和主键,或用数组方式指出删除条件
delete($table,$keyarr)

第八个是更新数据,指定表名,数据,主键或是数组形式的更新条件
update($table,$data, $keyarr)

 

db.class.php

PHP代码
  1. <?php  
  2. /* 
  3. #  数据模型 
  4. #  PDO方式访问Mysql数据库,主要方法:利数组方式快速插入(insert) 利用数组做连表查询(findAll find) 
  5. #  作者:℃冻番茄 qq:7279915 
  6. #  web@ye55.com  www.ye55.com (蓝叶工作室) 
  7. */  
  8.   
  9. class db{  
  10.   
  11.     public $db;  
  12.     public $queryNum=0;  
  13.     public $querySql=array();  
  14.     public $error;  
  15.     public $cacheNum=0;  
  16.   
  17.     function __construct()  
  18.     {  
  19.         if(!$this->db= @new PDO(conf(‘dbType’).‘:host=’.conf(‘dbHost’).‘;dbname=’.conf(‘dbName’), conf(‘dbUser’), conf(‘dbPass’))){  
  20.             $this->error=‘数据库连接信息出错!’;  
  21.         }  
  22.         $this->db->exec(‘SET NAMES ‘.conf(‘charset’));   
  23.     }  
  24.   
  25.     function query($sql)  
  26.     {  
  27.         $rs = $this->db->query($sql);  
  28.         $this->queryNum++;  
  29.         $this->querySql[]=$sql;  
  30.         return $rs;  
  31.     }  
  32.   
  33.   
  34.     function beginTransaction()  
  35.     {  
  36.         return $this->db->beginTransaction();  
  37.     }  
  38.   
  39.     function commit()  
  40.     {  
  41.         return $this->db->commit();  
  42.     }  
  43.   
  44.     function rollBack()  
  45.     {  
  46.         return $this->db->rollBack();  
  47.     }  
  48.   
  49.     function exec($sql)  
  50.     {  
  51.         $this->queryNum++;  
  52.         $this->querySql[]=$sql;  
  53.         return $this->db->exec($sql);  
  54.     }  
  55.   
  56.     function lastInsertId()  
  57.     {  
  58.         return $this->db->lastInsertId();  
  59.     }  
  60.   
  61.   
  62.     function setAttribute($attr$value)  
  63.     {  
  64.         return $this->db->setAttribute($attr$value);  
  65.     }  
  66.   
  67.   
  68.     function insert($table,$data)  
  69.     {  
  70.         $table=conf(‘dbprefix’).$table;  
  71.         $fields = "";  
  72.         $values = "";  
  73.         $tableCache=$this->tableCache($table);  
  74.         $tableCache=$tableCache[$table];  
  75.         foreach($data as $field=>$value)  
  76.         {  
  77.             if(in_array($field,$tableCache[‘field’])){  
  78.                 $fields .= "`$field`, ";  
  79.                 $values .= "’".mysql_escape_string($value)."’, ";  
  80.             }  
  81.         }  
  82.           
  83.         $fields = substr_replace($fields"", -2, 1);  
  84.         $values = substr_replace($values"", -2, 1);  
  85.   
  86.         $sql = "insert into `$table` ($fields) values ($values)";  
  87.           
  88.         //echo $sql;  
  89.         if($rs = $this->query($sql)){  
  90.             return $this->lastInsertId();  
  91.         }else{  
  92.             $this->error=‘插入数据出错!’;  
  93.             return false;  
  94.         }  
  95.           
  96.     }  
  97.   
  98.     function delete($table,$keyarr){  
  99.         $table=conf(‘dbprefix’).$table;  
  100.         if(is_array($keyarr)){  
  101.             $where = " where ";  
  102.             foreach($keyarr as $key=>$key_value)  
  103.             {  
  104.                 $where .= " `$key`=’".mysql_escape_string($key_value)."’ and";  
  105.             }  
  106.             $where=substr($where,0,-3);  
  107.         }else{  
  108.             $tableCache=$this->tableCache($table);  
  109.             $where =" where `".$tableCache[$table][‘key’]."`=’".mysql_escape_string($keyarr)."’";  
  110.             unset($tableCache);  
  111.         }  
  112.         $sql = "delete from `$table` $where";  
  113.         //echo $sql;  
  114.         if(!$rs =$this->query($sql)){  
  115.             $this->error=‘插入数据出错!’;  
  116.         }  
  117.         return $rs;  
  118.     }  
  119.   
  120.     function update($table,$data$keyarr)  
  121.     {  
  122.         $table=conf(‘dbprefix’).$table;  
  123.         $set = "";  
  124.         $tableCache=$this->tableCache($table);  
  125.         $tableCache=$tableCache[$table];  
  126.         //dump($data);  
  127.         foreach($data as $field=>$value)  
  128.         {  
  129.             if(in_array($field,$tableCache[‘field’])){  
  130.                 $set .= "`$field`=’".mysql_escape_string($value)."’, ";  
  131.             }  
  132.         }  
  133.         $set = substr_replace($set"", -2, 1);  
  134.         if(is_array($keyarr)){  
  135.             $where = " where ";  
  136.             foreach($keyarr as $key=>$key_value)  
  137.             {  
  138.                 $where .= "`$key`=’$key_value’";  
  139.             }  
  140.         }else{  
  141.             $where =" where `".$tableCache[‘key’]."`=’".mysql_escape_string($keyarr)."’";  
  142.         }  
  143.         unset($tableCache);  
  144.         $sql = "update `$table` set $set  $where";  
  145.         //echo $sql;  
  146.         if(!$rs =$this->query($sql)){  
  147.             $this->error=‘更新数据出错!’;  
  148.         }  
  149.           
  150.         return $rs;  
  151.     }  
  152.   
  153.     function find($table,$where=,$field=‘*’,$order=,$limit=,$group=)  
  154.     {  
  155.         $sql=$this->_map($table,$where,$field,$order,$limit,$group);  
  156.           
  157.         return $this->_find($sql);  
  158.     }  
  159.       
  160.     function findAll($table,$where=,$field=‘*’,$order=,$limit=,$group=)  
  161.     {  
  162.         $sql=$this->_map($table,$where,$field,$order,$limit,$group);  
  163.         //echo $sql;  
  164.         return $this->_findAll($sql);  
  165.     }  
  166.       
  167.     function fullText($table,$key,$str,$where=,$field=‘*’,$limit=,$group=)  
  168.     {  
  169.         $order=emptyempty($order)?:‘order by ‘.$order;  
  170.         $limit=emptyempty($limit)?:‘limit ‘.mysql_escape_string($limit);  
  171.         $group=emptyempty($group)?:‘group by ‘.$group;  
  172.         $field=emptyempty($field)?‘*’:$field;  
  173.         $w="where MATCH ($key) against (‘$str’) ".$where;  
  174.           
  175.         if(is_array($table)){  
  176.             $table1=conf(‘dbprefix’).$table[0];  
  177.             //echo $table1;  
  178.             $count=count($table);  
  179.             $joinleft=;  
  180.             array_shift($table);  
  181.             foreach($table as $v){  
  182.                 foreach($v as $k2=>$v2){  
  183.                     $k2=conf(‘dbprefix’).$k2;  
  184.                     foreach($v2 as $k3=>$v3){  
  185.                         $l="$table1.$k3=$k2.$v3";  
  186.                     }  
  187.                     $joinleft.="left join $k2 on $l ";  
  188.                 }  
  189.             }  
  190.             $sql="select $field from $table1 $joinleft $w $order $group $limit";  
  191.         }else{  
  192.             $table=conf(‘dbprefix’).$table;  
  193.             $sql="select $field from $table $w  $order $group $limit";  
  194.         }  
  195.         //echo $sql;  
  196.         $rs=$this->query($sql);  
  197.         $row=$rs->fetchall(PDO::FETCH_ASSOC);  
  198.         return $row;  
  199.     }  
  200.       
  201.     function dbCache($time,$func,$table,$where=,$field=‘*’,$order=,$limit=,$group=)  
  202.     {  
  203.         if($func!=‘find’ && $func!=‘findAll’return false;  
  204.         if(emptyempty($time)){  
  205.             return $this->$func($table,$where,$field,$order,$limit,$group);  
  206.         }  
  207.         $tableStr=is_array($table)?serialize($table):$table;  
  208.         $whereStr=is_array($where)?serialize($where):$where;  
  209.         $file=conf(‘cacheDir’).‘/’.$func.‘.’.md5($tableStr.$whereStr.$field.$order.$limit.$group).‘.php’;  
  210.           
  211.         if(file_exists($file)){  
  212.             if(time()-filemtime($file)<$time){  
  213.                 $content=file_get_contents($file);  
  214.                 $arr=unserialize(substr($content,13));  
  215.                 $this->cacheNum++;  
  216.                 return $arr;  
  217.             }else{  
  218.                 return $this->_dbWriteCache($file,$func,$table,$where,$field,$order,$limit,$group);  
  219.             }  
  220.         }else{  
  221.             return $this->_dbWriteCache($file,$func,$table,$where,$field,$order,$limit,$group);  
  222.         }  
  223.     }  
  224.       
  225.     private function _dbWriteCache($file,$func,$table,$where,$field,$order,$limit,$group)  
  226.     {  
  227.         fclose(fopen($file"w"));  
  228.         $arr=$this->$func($table,$where,$field,$order,$limit,$group);  
  229.         $content=‘<?php exit;?>’.serialize($arr);  
  230.         if(file_put_contents($file,$content)){  
  231.             return $arr;  
  232.         }else{  
  233.             $this->error=‘缓存写入出错!’;  
  234.             return false;  
  235.         }  
  236.     }  
  237.   
  238.     function count($table,$where=,$order=,$group=)  
  239.     {  
  240.         $tableCache=$this->tableCache($table);  
  241.         $tableCache=$tableCache[$table];  
  242.         $sql=$this->_map($table,$where,‘count(‘.conf(‘dbprefix’).$table.‘.’.$tableCache[‘key’].‘)’,$order,,$group);  
  243.         //echo $sql;  
  244.         return $this->_count($sql);  
  245.     }  
  246.       
  247.       
  248.       
  249.     private function _count($sql)  
  250.     {  
  251.         $rs=$this->query($sql);  
  252.         $count=$rs->fetchColumn();  
  253.         $count=emptyempty($count)?0:$count;  
  254.         return $count;  
  255.     }  
  256.       
  257.     private function _find($sql)  
  258.     {  
  259.         $rs=$this->query($sql);  
  260.         $row=$rs->fetch(PDO::FETCH_ASSOC);  
  261.         return $row;  
  262.     }  
  263.       
  264.     private function _findAll($sql)  
  265.     {  
  266.         $rs=$this->query($sql);  
  267.         //echo $sql;  
  268.         $row=$rs->fetchall(PDO::FETCH_ASSOC);  
  269.         return $row;  
  270.     }  
  271.       
  272.   
  273.     /** 
  274.     +———————————————————- 
  275.     * 指定表名,条件,字段,排序,个数等组合sql 
  276.     +———————————————————- 
  277.     * @return string 
  278.     +———————————————————- 
  279.     */    
  280.     private function _map($table,$where=,$field=‘*’,$order=,$limit=,$group=)  
  281.     {  
  282.         $order=emptyempty($order)?:‘order by ‘.$order;  
  283.         $limit=emptyempty($limit)?:‘limit ‘.mysql_escape_string($limit);  
  284.         $group=emptyempty($group)?:‘group by ‘.$group;  
  285.         $field=emptyempty($field)?‘*’:$field;  
  286.         $w=;  
  287.           
  288.         if(!emptyempty($where)){  
  289.             if(is_array($where)){  
  290.                 $w.=‘where’;  
  291.                 foreach($where as $k=>$v){  
  292.                     $w.=" $k=’$v’ and";  
  293.                 }  
  294.                 $w=substr($w,0,strlen($w)-3);  
  295.             }elseif(!preg_match ("/where/i",$where) && !is_array($table)){  
  296.               
  297.                 $tableCache=$this->tableCache($table);  
  298.                 $w=" where `".$tableCache[$table][‘key’]."`=’".mysql_escape_string($where)."’";  
  299.                 unset($tableCache);  
  300.             }else{  
  301.                   
  302.                 $w=$where;  
  303.             }  
  304.         }  
  305.           
  306.         if(is_array($table)){  
  307.             $table1=conf(‘dbprefix’).$table[0];  
  308.             //echo $table1;  
  309.             $count=count($table);  
  310.             $joinleft=;  
  311.             array_shift($table);  
  312.             foreach($table as $v){  
  313.                 foreach($v as $k2=>$v2){  
  314.                     $k2=conf(‘dbprefix’).$k2;  
  315.                     foreach($v2 as $k3=>$v3){  
  316.                         $l="$table1.$k3=$k2.$v3";  
  317.                     }  
  318.                     $joinleft.="left join $k2 on $l ";  
  319.                 }  
  320.             }  
  321.             $sql="select $field from $table1 $joinleft $w $order $group $limit";  
  322.         }else{  
  323.             $table=conf(‘dbprefix’).$table;  
  324.             $sql="select $field from $table $w  $order $group $limit";  
  325.         }  
  326.         //echo $sql;  
  327.         return $sql;  
  328.     }  
  329.       
  330.     /** 
  331.     +———————————————————- 
  332.     * 读取指定表的主键及字段,如缓存文件里不存在指定表的信息,则写入 
  333.     +———————————————————- 
  334.     * @param string $table 表名 
  335.     +———————————————————- 
  336.     * @return array 
  337.     +———————————————————- 
  338.     */  
  339.       
  340.     private function tableCache($table)  
  341.     {  
  342.         $this->tableCacheFile=conf(‘cacheDir’).‘/table.inc.php’;  
  343.       
  344.         if(file_exists($this->tableCacheFile)){  
  345.             $tableCache=@file_get_contents($this->tableCacheFile);  
  346.             $tableCache=unserialize(str_replace(‘<?php exit;?>’,,$tableCache));  
  347.             if(!isset($tableCache[$table])){  
  348.                 $arr=$this->_tableCache($table);  
  349.                 $tableCache=@array_merge($tableCache,$arr);  
  350.                 //dump($tableCache);  
  351.                 if(!$this->_writeTableCache($tableCache)){  
  352.                     $this->error=‘数据表缓存写入出错 TABLE:’.$table;  
  353.                 }  
  354.             }  
  355.         }else{  
  356.             $tableCache=$this->_tableCache($table);  
  357.             if(!$this->_writeTableCache($tableCache)){  
  358.                 $this->error=‘数据表缓存写入出错 TABLE:’.$table;  
  359.             }  
  360.         }  
  361.         //dump($tableCache);  
  362.         return $tableCache;  
  363.     }  
  364.       
  365.     /** 
  366.     +———————————————————- 
  367.     * 通过表名,获取些表的主键及所有字段 
  368.     +———————————————————- 
  369.     * @param string $table 表名 
  370.     +———————————————————- 
  371.     * @return array 
  372.     +———————————————————- 
  373.     */    
  374.     private function _tableCache($table)  
  375.     {  
  376.         $rs=$this->query("describe $table");  
  377.         $row=$rs->fetchall(PDO::FETCH_ASSOC);  
  378.         $tmp=array();  
  379.         foreach($row as $v){  
  380.             //echo $v[‘Field’];  
  381.             if($v[‘Key’]==‘PRI’)$key=$v[‘Field’];  
  382.             $tmp[]=$v[‘Field’];  
  383.         }  
  384.         $cache=array($table=>array(‘key’=>$key,‘field’=>$tmp));  
  385.         return $cache;  
  386.     }  
  387.       
  388.      /** 
  389.      +———————————————————- 
  390.      * 把数据表的字段及主键序列化写入缓存文件 
  391.      +———————————————————- 
  392.      * @param array $arr 数据表字段组成的数组 
  393.      +———————————————————- 
  394.      * @return bool 
  395.      +———————————————————- 
  396.      */   
  397.       
  398.     private function _writeTableCache($arr)  
  399.     {  
  400.         $content=‘<?php exit;?>’.serialize($arr);  
  401.         fclose(fopen($this->tableCacheFile,‘w’));  
  402.         if(file_put_contents($this->tableCacheFile,$content)){  
  403.             return true;  
  404.         }else{  
  405.             return false;  
  406.         }  
  407.     }  
  408.       
  409.   
  410.     /** 
  411.      +———————————————————- 
  412.      * 析构函数回调 
  413.      +———————————————————- 
  414.      */   
  415.     
  416.     function __destruct()  
  417.     {  
  418.         $this->db=null;  
  419.         define(‘QUERYNUM’,$this->queryNum);  
  420.         if(conf(‘debug’)){  
  421.             foreach ($this->querySql as $v){  
  422.                 $sql.=$v.‘<br />’;  
  423.             }  
  424.             define(‘QUERYSQL’,$sql);  
  425.             define(‘CACHENUM’,$this->cacheNum);  
  426.         }  
  427.     }  
  428.   
  429. }  
  430. //fetch(‘PDO_FETCH_ASSOC’)  
  431.   
  432. ?>  

test.php (演示)

PHP代码
  1. <?php  
  2. require_once(‘db.class.php’);  
  3. if(!defined(‘APP_PATH’)) define(‘APP_PATH’, dirname(__FILE__));  
  4. $charset=conf(‘charset’)==‘utf8’?‘utf-8’:conf(‘charset’);  
  5. header("content-type:text/html; charset=$charset");   
  6.   
  7. function config($configNew)  
  8. {  
  9.     $config=array(  
  10.             ‘cacheDir’=>APP_PATH.‘/’.‘cache’,  
  11.             ‘charset’=>‘utf8’,  
  12.             ‘dbType’=>‘mysql’,  
  13.             ‘sessionType’=>‘data’,  
  14.             ‘tplFilename’=>‘.html’,  
  15.             ‘dbLink’=>‘pdo’,  
  16.             ‘dbHost’=>,  
  17.             ‘dbName’=>,  
  18.             ‘dbUser’=>,  
  19.             ‘dbPass’=>,  
  20.             ‘dbprefix’=>,  
  21.             );  
  22.     $conf=array_merge($config,$configNew);  
  23.     return $conf;  
  24. }  
  25.   
  26. function conf($key)  
  27. {  
  28.     global $config;  
  29.     return $config[$key];  
  30. }  
  31. $config=config(array(‘dbHost’=>‘localhost’,‘dbName’=>‘rb’,‘dbUser’=>‘root’,‘dbPass’=>‘root’));  
  32. $db=new db();  
  33.   
  34. $list=$db->dbCache(100,‘findAll’,‘xzy_article_title’,,,‘aid desc’,20);  
  35. if(emptyempty($list)) exit;  
  36. echo ‘<ul>’;  
  37. foreach($list as $v){  
  38.     echo ‘<li>’.$v[‘title’].‘ [‘.date(‘Y-m-d’,$v[‘addtime’]).‘]</li>’;  
  39. }  
  40. echo ‘</ul>’;  
  41. ?>  

生成的数据缓存:
aac.jpg