php pdo数据库操作封装类代码

3. /**

4. 　* 数据库PDO操作
5. 　*/
6. class MysqlPdo {
7. public static $PDOStatement = null;
8. /**
9. * 数据库的连接参数配置
10. * @var array
11. * @access public
12. */
13. public static $config = array();
14. /**
15. * 是否使用永久连接
16. * @var bool
17. * @access public
18. */
19. public static $pconnect = false;
20. /**
21. * 错误信息
22. * @var string
23. * @access public
24. */
25. public static $error = '';
26. /**
27. * 单件模式,保存Pdo类唯一实例,数据库的连接资源
28. * @var object
29. * @access public
30. */
31. protected static $link;
32. /**
33. * 是否已经连接数据库
34. * @var bool
35. * @access public
36. */
37. public static $connected = false;
38. /**
39. * 数据库版本
40. * @var string
41. * @access public
42. */
43. public static $dbVersion = null;
44. /**
45. * 当前SQL语句
46. * @var string
47. * @access public
48. */
49. public static $queryStr = '';
50. /**
51. * 最后插入记录的ID
52. * @var integer
53. * @access public
54. */
55. public static $lastInsertId = null;
56. /**
57. * 返回影响记录数
58. * @var integer
59. * @access public
60. */
61. public static $numRows = 0;
62. // 事务指令数
63. public static $transTimes = 0;
64. /**
65. * 构造函数，
66. * @param $dbconfig 数据库连接相关信息，array('ServerName', 'UserName', 'Password', 'DefaultDb', 'DB_Port', 'DB_TYPE')
67. */
68. public function __construct($dbConfig=''){
69. if (!class_exists('PDO')) self::throw_exception("不支持:PDO");
70. //若没有传输任何参数，则使用默认的数据定义
71. if (!is_array($dbConfig)) {
72. $dbConfig = array(
73. 'hostname' => DB_HOST,
74. 'username' => DB_USER,
75. 'password' => DB_PWD,
76. 'database' => DB_NAME,
77. 'hostport' => DB_PORT,
78. 'dbms' => DB_TYPE,
79. 'dsn' => DB_TYPE.":host=".DB_HOST.";dbname=".DB_NAME
80. );
81. }
82. if(empty($dbConfig['hostname'])) self::throw_exception("没有定义数据库配置");
83. self::$config = $dbConfig;
84. if(empty(self::$config['params'])) self::$config['params'] = array();
85. /*************************************华丽分隔线*******************************************/
86. if (!isset(self::$link) ) {
87. $configs = self::$config;
88. if(self::$pconnect) {
89. $configs['params'][constant('PDO::ATTR_PERSISTENT')] = true;
90. }
91. try {
92. self::$link = new PDO( $configs['dsn'], $configs['username'], $configs['password'],$configs['params']);
93. } catch (PDOException $e) {
94. self::throw_exception($e->getMessage());
95. }
96. if(!self::$link) {
97. self::throw_exception('PDO CONNECT ERROR');
98. return false;
99. }
100. self::$link->exec('SET NAMES '.DB_CHARSET);
101. self::$dbVersion = self::$link->getAttribute(constant("PDO::ATTR_SERVER_INFO"));
102. // 标记连接成功
103. self::$connected = true;
104. // 注销数据库连接配置信息
105. unset($configs);
106. }
107. return self::$link;
108. }
109. /**
110. * 释放查询结果
111. * @access function
112. */
113. static function free() {
114. self::$PDOStatement = null;
115. }
116. /************************/
117. /* 数据库操作 */
118. /************************/
119. /**
120. * 获得所有的查询数据
121. * @access function
122. * @return array
123. */
124. static function getAll($sql=null) {
125. if($sql != null)
126. {
127. self::query($sql);
128. }
129. //返回数据集
130. $result = self::$PDOStatement->fetchAll(constant('PDO::FETCH_ASSOC'));
131. return $result;
132. }
133. /**
134. * 获得一条查询结果
135. * @access function
136. * @param string $sql SQL指令
137. * @param integer $seek 指针位置
138. * @return array
139. */
140. static function getRow($sql=null) {
141. if($sql != null)
142. {
143. self::query($sql);
144. }
145. // 返回数组集
146. $result = self::$PDOStatement->fetch(constant('PDO::FETCH_ASSOC'),constant('PDO::FETCH_ORI_NEXT'));
147. return $result;
148. }
149. /**
150. * 执行sql语句，自动判断进行查询或者执行操作
151. * @access function
152. * @param string $sql SQL指令
153. * @return mixed
154. */
155. static function doSql($sql='') {
156. if(self::isMainIps($sql)) {
157. return self::execute($sql);
158. }else {
159. return self::getAll($sql);
160. }
161. }
162. /**
163. * 根据指定ID查找表中记录(仅用于单表操作)
164. * @access function
165. * @param integer $priId 主键ID
166. * @param string $tables 数据表名
167. * @param string $fields 字段名
168. * @return ArrayObject 表记录
169. */
170. static function findById($tabName,$priId,$fields='*'){
171. $sql = 'SELECT %s FROM %s WHERE id=%d';
172. return self::getRow(sprintf($sql, self::parseFields($fields), $tabName, $priId));
173. }
174. /**
175. * 查找记录
176. * @access function
177. * @param string $tables 数据表名
178. * @param mixed $where 查询条件
179. * @param string $fields 字段名
180. * @param string $order 排序
181. * @param string $limit 取多少条数据
182. * @param string $group 分组
183. * @param string $having
184. * @param boolean $lock 是否加锁
185. * @return ArrayObject
186. */
187. static function find($tables,$where="",$fields='*',$order=null,$limit=null,$group=null,$having=null) {
188. $sql = 'SELECT '.self::parseFields($fields)
189. .' FROM '.$tables
190. .self::parseWhere($where)
191. .self::parseGroup($group)
192. .self::parseHaving($having)
193. .self::parseOrder($order)
194. .self::parseLimit($limit);
195. $dataAll = self::getAll($sql);
196. if(count($dataAll)==1){$rlt=$dataAll[0];}else{$rlt=$dataAll;}
197. return $rlt;
198. }
199. /**
200. * 插入（单条）记录
201. * @access function
202. * @param mixed $data 数据
203. * @param string $table 数据表名
204. * @return false | integer
205. */
206. function add($data,$table) {
207. //过滤提交数据
208. $data=self::filterPost($table,$data);
209. foreach ($data as $key=>$val){
210. if(is_array($val) && strtolower($val[0]) == 'exp') {
211. $val = $val[1]; // 使用表达式 ???
212. }elseif (is_scalar($val)){
213. $val = self::fieldFormat($val);
214. }else{
215. // 去掉复合对象
216. continue;
217. }
218. $data[$key] = $val;
219. }
220. $fields = array_keys($data);
221. array_walk($fields, array($this, 'addSpecialChar'));
222. $fieldsStr = implode(',', $fields);
223. $values = array_values($data);
224. $valuesStr = implode(',', $values);
225. $sql = 'INSERT INTO '.$table.' ('.$fieldsStr.') VALUES ('.$valuesStr.')';
226. return self::execute($sql);
227. }
228. /**
229. * 更新记录
230. * @access function
231. * @param mixed $sets 数据
232. * @param string $table 数据表名
233. * @param string $where 更新条件
234. * @param string $limit
235. * @param string $order
236. * @return false | integer
237. */
238. static function update($sets,$table,$where,$limit=0,$order='') {
239. $sets = self::filterPost($table,$sets);
240. $sql = 'UPDATE '.$table.' SET '.self::parseSets($sets).self::parseWhere($where).self::parseOrder($order).self::parseLimit($limit);
241. return self::execute($sql);
242. }
243. /**
244. * 保存某个字段的值
245. * @access function
246. * @param string $field 要保存的字段名
247. * @param string $value 字段值
248. * @param string $table 数据表
249. * @param string $where 保存条件
250. * @param boolean $asString 字段值是否为字符串
251. * @return void
252. */
253. static function setField($field, $value, $table, $condition="", $asString=false) {
254. // 如果有'(' 视为 SQL指令更新 否则 更新字段内容为纯字符串
255. if(false === strpos($value,'(') || $asString) $value = '"'.$value.'"';
256. $sql = 'UPDATE '.$table.' SET '.$field.'='.$value.self::parseWhere($condition);
257. return self::execute($sql);
258. }
259. /**
260. * 删除记录
261. * @access function
262. * @param mixed $where 为条件Map、Array或者String
263. * @param string $table 数据表名
264. * @param string $limit
265. * @param string $order
266. * @return false | integer
267. */
268. static function remove($where,$table,$limit='',$order='') {
269. $sql = 'DELETE FROM '.$table.self::parseWhere($where).self::parseOrder($order).self::parseLimit($limit);
270. return self::execute($sql);
271. }
272. /**
273. +----------------------------------------------------------
274. * 修改或保存数据(仅用于单表操作)
275. * 有主键ID则为修改，无主键ID则为增加
276. * 修改记录：
277. +----------------------------------------------------------
278. * @access function
279. +----------------------------------------------------------
280. * @param $tabName 表名
281. * @param $aPost 提交表单的 $_POST
282. * @param $priId 主键ID
283. * @param $aNot 要排除的一个字段或数组
284. * @param $aCustom 自定义的一个数组，附加到数据库中保存
285. * @param $isExits 是否已经存在 存在：true, 不存在：false
286. +----------------------------------------------------------
287. * @return Boolean 修改或保存是否成功
288. +----------------------------------------------------------
289. */
290. function saveOrUpdate($tabName, $aPost, $priId="", $aNot="", $aCustom="", $isExits=false) {
291. if(empty($tabName) || !is_array($aPost) || is_int($aNot)) return false;
292. if(is_string($aNot) && !empty($aNot)) $aNot = array($aNot);
293. if(is_array($aNot) && is_int(key($aNot))) $aPost = array_diff_key($aPost, array_flip($aNot));
294. if(is_array($aCustom) && is_string(key($aCustom))) $aPost = array_merge($aPost,$aCustom);
295. if (empty($priId) && !$isExits) { //新增
296. $aPost = array_filter($aPost, array($this, 'removeEmpty'));
297. return self::add($aPost, $tabName);
298. } else { //修改
299. return self::update($aPost, $tabName, "id=".$priId);
300. }
301. }
302. /**
303. * 获取最近一次查询的sql语句
304. * @access function
305. * @param
306. * @return String 执行的SQL
307. */
308. static function getLastSql() {
309. $link = self::$link;
310. if ( !$link ) return false;
311. return self::$queryStr;
312. }
313. /**
314. * 获取最后插入的ID
315. * @access function
316. * @param
317. * @return integer 最后插入时的数据ID
318. */
319. static function getLastInsId(){
320. $link = self::$link;
321. if ( !$link ) return false;
322. return self::$lastInsertId;
323. }
324. /**
325. * 获取DB版本
326. * @access function
327. * @param
328. * @return string
329. */
330. static function getDbVersion(){
331. $link = self::$link;
332. if ( !$link ) return false;
333. return self::$dbVersion;
334. }
335. /**
336. * 取得数据库的表信息
337. * @access function
338. * @return array
339. */
340. static function getTables() {
341. $info = array();
342. if(self::query("SHOW TABLES")) {
343. $result = self::getAll();
344. foreach ($result as $key => $val) {
345. $info[$key] = current($val);
346. }
347. }
348. return $info;
349. }
350. /**
351. * 取得数据表的字段信息
352. * @access function
353. * @return array
354. */
355. static function getFields($tableName) {
356. // 获取数据库联接
357. $link = self::$link;
358. $sql = "SELECT
359. ORDINAL_POSITION ,COLUMN_NAME, COLUMN_TYPE, DATA_TYPE,
360. IF(ISNULL(CHARACTER_MAXIMUM_LENGTH), (NUMERIC_PRECISION + NUMERIC_SCALE), CHARACTER_MAXIMUM_LENGTH) AS MAXCHAR,
361. IS_NULLABLE, COLUMN_DEFAULT, COLUMN_KEY, EXTRA, COLUMN_COMMENT
362. FROM
363. INFORMATION_SCHEMA.COLUMNS
364. WHERE
365. TABLE_NAME = :tabName AND TABLE_SCHEMA='".DB_NAME."'";
366. self::$queryStr = sprintf($sql, $tableName);
367. $sth = $link->prepare($sql);
368. $sth->bindParam(':tabName', $tableName);
369. $sth->execute();
370. $result = $sth->fetchAll(constant('PDO::FETCH_ASSOC'));
371. $info = array();
372. foreach ($result as $key => $val) {
373. $info[$val['COLUMN_NAME']] = array(
374. 'postion' => $val['ORDINAL_POSITION'],
375. 'name' => $val['COLUMN_NAME'],
376. 'type' => $val['COLUMN_TYPE'],
377. 'd_type' => $val['DATA_TYPE'],
378. 'length' => $val['MAXCHAR'],
379. 'notnull' => (strtolower($val['IS_NULLABLE']) == "no"),
380. 'default' => $val['COLUMN_DEFAULT'],
381. 'primary' => (strtolower($val['COLUMN_KEY']) == 'pri'),
382. 'autoInc' => (strtolower($val['EXTRA']) == 'auto_increment'),
383. 'comment' => $val['COLUMN_COMMENT']
384. );
385. }
386. // 有错误则抛出异常
387. self::haveErrorThrowException();
388. return $info;
389. }
390. /**
391. * 关闭数据库
392. * @access function
393. */
394. static function close() {
395. self::$link = null;
396. }
397. /**
398. * SQL指令安全过滤
399. * @access function
400. * @param string $str SQL指令
401. * @return string
402. */
403. static function escape_string($str) {
404. return addslashes($str);
405. }
406. /************************/
407. /* 内部操作方法 */
408. /************************/
409. /**
410. * 有出错抛出异常
411. * @access function
412. * @return
413. */
414. static function haveErrorThrowException() {
415. $obj = empty(self::$PDOStatement) ? self::$link : self::$PDOStatement;
416. $arrError = $obj->errorInfo();
417. if($arrError[0] !== '00000') { // 有错误信息
418. self::$error = $arrError[0]."|".$arrError[2]. "
     [ SQL ] : ".self::$queryStr."
     ";
419. self::throw_exception(self::$error);
420. return false;
421. }
422. //主要针对execute()方法抛出异常
423. if(self::$queryStr=='')self::throw_exception('Query was empty
     
     [ SQL语句 ] :');
424. }
425. /**
426. * where分析
427. * @access function
428. * @param mixed $where 查询条件
429. * @return string
430. */
431. static function parseWhere($where) {
432. $whereStr = '';
433. if(is_string($where) || is_null($where)) {
434. $whereStr = $where;
435. }
436. return empty($whereStr)?'':' WHERE '.$whereStr;
437. }
438. /**
439. * order分析
440. * @access function
441. * @param mixed $order 排序
442. * @return string
443. */
444. static function parseOrder($order) {
445. $orderStr = '';
446. if(is_array($order))
447. $orderStr .= ' ORDER BY '.implode(',', $order);
448. else if(is_string($order) && !empty($order))
449. $orderStr .= ' ORDER BY '.$order;
450. return $orderStr;
451. }
452. /**
453. * limit分析
454. * @access function
455. * @param string $limit
456. * @return string
457. */
458. static function parseLimit($limit) {
459. $limitStr = '';
460. if(is_array($limit)) {
461. if(count($limit)>1)
462. $limitStr .= ' LIMIT '.$limit[0].' , '.$limit[1].' ';
463. else
464. $limitStr .= ' LIMIT '.$limit[0].' ';
465. } else if(is_string($limit) && !empty($limit)) {
466. $limitStr .= ' LIMIT '.$limit.' ';
467. }
468. return $limitStr;
469. }
470. /**
471. * group分析
472. * @access function
473. * @param mixed $group
474. * @return string
475. */
476. static function parseGroup($group) {
477. $groupStr = '';
478. if(is_array($group))
479. $groupStr .= ' GROUP BY '.implode(',', $group);
480. else if(is_string($group) && !empty($group))
481. $groupStr .= ' GROUP BY '.$group;
482. return empty($groupStr)?'':$groupStr;
483. }
484. /**
485. * having分析
486. * @access function
487. * @param string $having
488. * @return string
489. */
490. static function parseHaving($having) {
491. $havingStr = '';
492. if(is_string($having) && !empty($having))
493. $havingStr .= ' HAVING '.$having;
494. return $havingStr;
495. }
496. /**
497. * fields分析
498. * @access function
499. * @param mixed $fields
500. * @return string
501. */
502. function parseFields($fields) {
503. if(is_array($fields)) {
504. array_walk($fields, array($this, 'addSpecialChar'));
505. $fieldsStr = implode(',', $fields);
506. }else if(is_string($fields) && !empty($fields)) {
507. if( false === strpos($fields,'`') ) {
508. $fields = explode(',',$fields);
509. array_walk($fields, array($this, 'addSpecialChar'));
510. $fieldsStr = implode(',', $fields);
511. }else {
512. $fieldsStr = $fields;
513. }
514. }else $fieldsStr = '*';
515. return $fieldsStr;
516. }
517. /**
518. * sets分析,在更新数据时调用
519. * @access function
520. * @param mixed $values
521. * @return string
522. */
523. private function parseSets($sets) {
524. $setsStr = '';
525. if(is_array($sets)){
526. foreach ($sets as $key=>$val){
527. $key = self::addSpecialChar($key);
528. $val = self::fieldFormat($val);
529. $setsStr .= "$key = ".$val.",";
530. }
531. $setsStr = substr($setsStr,0,-1);
532. }else if(is_string($sets)) {
533. $setsStr = $sets;
534. }
535. return $setsStr;
536. }
537. /**
538. * 字段格式化
539. * @access function
540. * @param mixed $value
541. * @return mixed
542. */
543. static function fieldFormat(&$value) {
544. if(is_int($value)) {
545. $value = intval($value);
546. } else if(is_float($value)) {
547. $value = floatval($value);
548. } elseif(preg_match('/^\(\w*(\+|\-|\*|\/)?\w*\)$/i',$value)){
549. // 支持在字段的值里面直接使用其它字段
550. // 例如 (score+1) (name) 必须包含括号
551. $value = $value;
552. }else if(is_string($value)) {
553. $value = '\''.self::escape_string($value).'\'';
554. }
555. return $value;
556. }
557. /**
558. * 字段和表名添加` 符合
559. * 保证指令中使用关键字不出错 针对mysql
560. * @access function
561. * @param mixed $value
562. * @return mixed
563. */
564. static function addSpecialChar(&$value) {
565. if( '*' == $value || false !== strpos($value,'(') || false !== strpos($value,'.') || false !== strpos($value,'`')) {
566. //如果包含* 或者 使用了sql方法 则不作处理
567. } elseif(false === strpos($value,'`') ) {
568. $value = '`'.trim($value).'`';
569. }
570. return $value;
571. }
572. /**
573. +----------------------------------------------------------
574. * 去掉空元素
575. +----------------------------------------------------------
576. * @access function
577. +----------------------------------------------------------
578. * @param mixed $value
579. +----------------------------------------------------------
580. * @return mixed
581. +----------------------------------------------------------
582. */
583. static function removeEmpty($value){
584. return !empty($value);
585. }
586. /**
587. * 执行查询 主要针对 SELECT, SHOW 等指令
588. * @access function
589. * @param string $sql sql指令
590. * @return mixed
591. */
592. static function query($sql='') {
593. // 获取数据库联接
594. $link = self::$link;
595. if ( !$link ) return false;
596. self::$queryStr = $sql;
597. //释放前次的查询结果
598. if ( !empty(self::$PDOStatement) ) self::free();
599. self::$PDOStatement = $link->prepare(self::$queryStr);
600. $bol = self::$PDOStatement->execute();
601. // 有错误则抛出异常
602. self::haveErrorThrowException();
603. return $bol;
604. }
605. /**
606. * 数据库操作方法
607. * @access function
608. * @param string $sql 执行语句
609. * @param boolean $lock 是否锁定(默认不锁定)
610. * @return void
611. public function execute($sql='',$lock=false) {
612. if(empty($sql)) $sql = $this->queryStr;
613. return $this->_execute($sql);
614. }*/
615. /**
616. * 执行语句 针对 INSERT, UPDATE 以及DELETE
617. * @access function
618. * @param string $sql sql指令
619. * @return integer
620. */
621. static function execute($sql='') {
622. // 获取数据库联接
623. $link = self::$link;
624. if ( !$link ) return false;
625. self::$queryStr = $sql;
626. //释放前次的查询结果
627. if ( !empty(self::$PDOStatement) ) self::free();
628. $result = $link->exec(self::$queryStr);
629. // 有错误则抛出异常
630. self::haveErrorThrowException();
631. if ( false === $result) {
632. return false;
633. } else {
634. self::$numRows = $result;
635. self::$lastInsertId = $link->lastInsertId();
636. return self::$numRows;
637. }
638. }
639. /**
640. * 是否为数据库更改操作
641. * @access private
642. * @param string $query SQL指令
643. * @return boolen 如果是查询操作返回false
644. */
645. static function isMainIps($query) {
646. $queryIps = 'INSERT|UPDATE|DELETE|REPLACE|CREATE|DROP|LOAD DATA|SELECT .* INTO|COPY|ALTER|GRANT|REVOKE|LOCK|UNLOCK';
647. if (preg_match('/^\s*"?(' . $queryIps . ')\s+/i', $query)) {
648. return true;
649. }
650. return false;
651. }
652. /**
653. * 过滤POST提交数据
654. * @access private
655. * @param mixed $data POST提交数据
656. * @param string $table 数据表名
657. * @return mixed $newdata
658. */
659. static function filterPost($table,$data) {
660. $table_column = self::getFields($table);
661. $newdata=array();
662. foreach ($table_column as $key=>$val){
663. if(array_key_exists($key,$data) && ($data[$key])!==''){
664. $newdata[$key] = $data[$key];
665. }
666. }
667. return $newdata;
668. }
669. /**
670. * 启动事务
671. * @access function
672. * @return void
673. */
674. static function startTrans() {
675. //数据rollback 支持
676. $link = self::$link;
677. if ( !$link ) return false;
678. if (self::$transTimes == 0) {
679. $link->beginTransaction();
680. }
681. self::$transTimes++;
682. return ;
683. }
684. /**
685. * 用于非自动提交状态下面的查询提交
686. * @access function
687. * @return boolen
688. */
689. static function commit() {
690. $link = self::$link;
691. if ( !$link ) return false;
692. if (self::$transTimes > 0) {
693. $result = $link->commit();
694. self::$transTimes = 0;
695. if(!$result){
696. self::throw_exception(self::$error());
697. return false;
698. }
699. }
700. return true;
701. }
702. /**
703. * 事务回滚
704. * @access function
705. * @return boolen
706. */
707. public function rollback() {
708. $link = self::$link;
709. if ( !$link ) return false;
710. if (self::$transTimes > 0) {
711. $result = $link->rollback();
712. self::$transTimes = 0;
713. if(!$result){
714. self::throw_exception(self::$error());
715. return false;
716. }
717. }
718. return true;
719. }

720. /**

721. * 错误处理
722. * @access function
723. * @return void
724. */
725. static function throw_exception($err){
726. echo '
     ERROR:'.$err.'
     ';
727. }
728. }

复制代码