찾다

집 >백엔드 개발 >PHP 튜토리얼 >PHP PDO 데이터베이스 작업 캡슐화 클래스 코드

PHP PDO 데이터베이스 작업 캡슐화 클래스 코드

WBOY
WBOY원래의
2016-07-25 08:51:521107검색

  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 정수
  53. * @access public
  54. */
  55. public static $lastInsertId = null;
  56. /**
  57. * 영향을 받은 레코드 수를 반환합니다.
  58. * @var 정수
  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. 공용 함수 __construct($dbConfig=''){
  69. if (!class_exists('PDO') ) self::throw_Exception("지원되지 않음: PDO");
  70. //매개변수가 전송되지 않으면 기본 데이터 정의가 사용됩니다
  71. if (!is_array($dbConfig)) {
  72. $dbConfig = 배열(
  73. '호스트 이름' => DB_HOST,
  74. '사용자 이름' => DB_USER,
  75. '비밀번호' => DB_PWD,
  76. '데이터베이스' => DB_NAME,
  77. '호스트 포트' => ; 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. {
  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 연결 오류');
  98. 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 함수
  112. */
  113. 정적 함수 무료 () {
  114. self::$PDOStatement = null;
  115. }
  116. /************************/
  117. /* 데이터베이스 작업*/
  118. /************************/
  119. /**
  120. * 모든 쿼리 데이터 가져오기
  121. * @access 함수
  122. * @return 배열
  123. */
  124. 정적 함수 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 함수
  136. * @param string $sql SQL 명령
  137. * @param 정수 $seek 포인터 위치
  138. * @return 배열
  139. */
  140. 정적 함수 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 함수
  152. * @param string $sql SQL 명령
  153. * @return 혼합
  154. */
  155. 정적 함수 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 함수
  165. * @param 정수 $priId 기본 키 ID
  166. * @param string $tables 데이터 테이블 이름
  167. * @param string $fields 필드 이름
  168. * @return ArrayObject 테이블 레코드
  169. */
  170. 정적 함수 findById($tabName,$priId,$fields='*'){
  171. $sql = 'SELECT %s FROM %s WHERE id=%d';
  172. 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. 靜態函數 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. 繼續;
  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 = '插入'.$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. 靜態函數update($sets,$table,$where,$limit=0,$order='') {
  239. $sets = self::filterPost($table,$sets);
  240. $sql = '更新「.$表」。 self::execute($sql );
  241. }
  242. /**
  243. * 儲存某個欄位的值
  244. * @access function
  245. * @param string $field 要儲存的欄位名稱
  246. * @param string $value 欄位值
  247. * @param string $ table 資料表
  248. * @param string $where 儲存條件
  249. * @param boolean $asString 欄位值是否為字串
  250. * @return void
  251. */
  252. 靜態函式setField($field, $value, $table, $condition="", $asString=false ) {
  253. //如果有'(' 視為SQL 指令更新否則更新欄位內容為純字串
  254. if(false === strpos($value,'(') || $asString) $value = '"'.$value .'"';
  255. $sql = '更新'.$table.' SET '.$field.'='.$value.self::parseWhere($condition);
  256. 回傳self::execute( $sql);
  257. }
  258. /**
  259. * 刪除記錄
  260. * @access function
  261. * @param mixed $where 為條件Map、Array或String
  262. * @param string $table 資料表名
  263. * @param string $limit
  264. * @param string $order
  265. * @return false | integer
  266. */靜態函式($where,$table,$limit='',$order='' ) {
  267. $sql = 'DELETE FROM '.$table.self::parseWhere($where).self::parseOrder($order).self::parseLimit($limit);
  268. 回傳self::執行($sql);
  269. }
  270. /**
  271. ----------------------------------------------- -----------
  272. * 修改或儲存資料(僅用於單表操作)
  273. * 有主鍵ID則為修改，無主鍵ID則為增加
  274. * 修改記錄：
  275. ---------------------------------------------- ------------
  276. * @access function
  277. ---------------------------- ------------------------------
  278. * @param $tabName 表名
  279. * @param $aPost 提交表單的$_POST
  280. * @param $priId 主鍵ID
  281. * @param $aNot 要排除的一個字段或數組
  282. * @param $aCustom 自訂的數組，附加到資料庫中保存
  283. * @param $isExits 是否已經存在存在：true, 不存在：false
  284. ------------------------------- ---------------------------
  285. * @return Boolean 修改或儲存是否成功
  286. -------- --------------------------------------------------
  287. */
  288. 函數saveOrUpdate($tabName, $aPost, $priId="", $aNot="", $aCustom="" , $isExits=false) {
  289. if(empty($tabName) || !is_array($aPost) || is_int($aNot)) return false;
  290. if(is_string($aNot) && !empty($aNot)) $aNot = array($aNot);
  291. if(is_array($aNot) && is_int(key ) ($aNot))) $aPost = array_diff_key($aPost, array_flip($aNot));
  292. if(is_array($aCustom) ) && is_string(key($aCustom))) $aPost = array_merge($aCustom))) $aPost = array_merge($aCustom))) $aPost = aPostge($aPost , $aCustom);
  293. if (empty($priId) && !$isExits) { // 新增
  294. $aPost = array_filter ($aPost, array($this, 'removeEmpty'));
  295. return self::add($aPost, $tabName);
  296. }else { //修改
  297. return self::update($aPost, $tabName, "id=".$priId);
  298. }
  299. }
  300. /**
  301. * 최신 쿼리의 sql 문 가져오기
  302. * @access 함수
  303. * @param
  304. * @return String 실행된 SQL
  305. */
  306. 정적 함수 getLastSql() {
  307. $link = self::$link;
  308. if ( !$link ) return false;
  309. return self::$queryStr;
  310. }
  311. /* *
  312. * 마지막으로 삽입된 ID 가져오기
  313. * @access 함수
  314. * @param
  315. * @return 정수 마지막으로 삽입된 데이터 ID
  316. */
  317. 정적 함수 getLastInsId(){
  318. $link = self::$link;
  319. if ( !$link ) return false;
  320. return self::$lastInsertId;
  321. }
  322. /**
  323. * DB 버전 가져오기
  324. * @access 함수
  325. * @param
  326. * @return 문자열
  327. */
  328. 정적 함수 getDbVersion(){
  329. $link = self::$link;
  330. if ( !$link ) return false;
  331. return self::$dbVersion;
  332. }
  333. /**
  334. * 데이터베이스 테이블 정보 가져오기
  335. * @access 함수
  336. * @return 배열
  337. */
  338. 정적 함수 getTables() {
  339. $info = array();
  340. if(self::query ("테이블 표시")) {
  341. $result = self::getAll();
  342. foreach ($result as $key => $val) {
  343. $info[$key] = current( $val);
  344. }
  345. }
  346. return $info;
  347. }
  348. /**
  349. * 데이터 테이블의 필드 정보 가져오기
  350. * @access 함수
  351. * @return 배열
  352. */
  353. 정적 함수 getFields($tableName) {
  354. //获取数据库联接
  355. $link = self::$link;
  356. $sql = "SELECT
  357. ORDINAL_POSITION ,COLUMN_NAME, COLUMN_TYPE, DATA_TYPE,
  358. IF(ISNULL(CHARACTER_MAXIMUM_LENGTH), (NUMERIC_PRECISION NUMERIC_SCALE ), CHARACTER_MAXIMUM_LENGTH ) AS MAXCHAR,
  359. IS_NULLABLE, COLUMN_DEFAULT, COLUMN_KEY, EXTRA, COLUMN_COMMENT
  360. FROM
  361. INFORMATION_SCHEMA.COLUMNS
  362. WHERE
  363. TABLE_NAME = :tabName AND TABLE_SCHEMA='".DB_NAME."'";
  364. self::$queryStr = sprintf($sql, $tableName);
  365. $sth = $link->prepare($sql);
  366. $sth->bindParam(':tabName', $ tableName);
  367. $sth->execute();
  368. $result = $sth->fetchAll(constant('PDO::FETCH_ASSOC'));
  369. $info = array();
  370. foreach($result as $key => $val) {
  371. $info[$val['COLUMN_NAME']] = array(
  372. '위치' => $val['ORDINAL_POSITION'],
  373. '이름' => $val[ 'COLUMN_NAME'],
  374. '유형' => $val['COLUMN_TYPE'],
  375. 'd_type' => $val['DATA_TYPE'],
  376. '길이' => ['MAXCHAR'],
  377. 'notnull' => (strtolower($val['IS_NULLABLE']) == "아니요"),
  378. 'default' => $val['COLUMN_DEFAULT'],
  379. '기본' => (strtolower($val['COLUMN_KEY']) == '기본'),
  380. 'autoInc' => (strtolower($val['EXTRA']) == ' auto_increment'),
  381. 'comment' => $val['COLUMN_COMMENT']
  382. );
  383. }
  384. // 有错误则抛take异常
  385. self::haveErrorThrowException();
  386. $info 반환;
  387. }
  388. /**
  389. * 데이터베이스 닫기
  390. * @access 함수
  391. */
  392. 정적 함수 close() {
  393. self::$link = null;
  394. }
  395. / **
  396. * SQL 명령 보안 필터링
  397. * @access 함수
  398. * @param string $str SQL 명령
  399. * @return string
  400. */
  401. 정적 함수 escape_string($str) {
  402. return addedlashes($str);
  403. }
  404. /************************/
  405. /* 内part操작 방법 */
  406. /************************/
  407. /**
  408. * 오류가 발생하고 예외가 발생합니다
  409. * @access 함수
  410. * @return
  411. */
  412. static function haveErrorThrowException() {
  413. $obj =empty(self::$PDOStatement) ? self::$link : self::$PDOStatement;
  414. $arrError = $obj->errorInfo();
  415. if($arrError[0] !== '00000') { // 有错误信息
  416. self::$error = $arrError[0]."|".$arrError[2]. "
    [ SQL ] : ".self::$queryStr."
    ";
  417. self::throw_Exception(self::$error);
  418. false를 반환;
  419. }
  420. //主要针对execute()방법법抛出异常
  421. if(self::$queryStr=='')self::throw_Exception('쿼리가 비어 있었습니다

    [ SQL语句 ] :');
  422. }
  423. /**
  424. * where 분석
  425. * @access 함수
  426. * @param $where 쿼리 조건 혼합
  427. * @return 문자열
  428. */
  429. 정적 함수 구문 분석($where) {
  430. $whereStr = '';
  431. if( is_string($where) || is_null($where)) {
  432. $whereStr = $where;
  433. }
  434. 빈 값 반환($whereStr)?'':' WHERE '.$whereStr;
  435. }
  436. /**
  437. * order 분석
  438. * @access function
  439. * @param mixed $order 배제
  440. * @return string
  441. */
  442. 정적 함수 parseOrder($order) {
  443. $orderStr = '';
  444. if(is_array($order))
  445. $orderStr .= ' ORDER BY '.implode(',', $order);
  446. else if(is_string($order) && !empty($order))
  447. $orderStr .= ' ORDER BY '.$order;
  448. return $orderStr;
  449. }
  450. /**
  451. * 제한분할
  452. * @access 함수
  453. * @param string $limit
  454. * @return string
  455. */
  456. 정적 함수 parseLimit($limit) {
  457. $limitStr = '';
  458. if(is_array($limit) )) {
  459. if(count($limit)>1)
  460. $limitStr .= ' LIMIT '.$limit[0].' , '.$limit[1].' ';
  461. else
  462. $limitStr .= ' LIMIT '.$limit[0].' ';
  463. } else if(is_string($limit) && !empty($limit)) {
  464. $limitStr .= ' LIMIT '.$limit.' ';
  465. }
  466. $limitStr 반환
  467. }
  468. /**
  469. * 그룹 분할
  470. * @access 함수
  471. * @param 혼합 $group
  472. * @return 문자열
  473. */
  474. 정적 함수 parseGroup($group) {
  475. $groupStr = '';
  476. if(is_array($group))
  477. $groupStr .= ' GROUP BY '.implode(',', $group);
  478. else if(is_string($group) && !empty($group))
  479. $groupStr .= ' GROUP BY '.$group;
  480. empty($groupStr)?'':$groupStr;
  481. }
  482. /**
  483. * have分析
  484. * @access 함수
  485. * @param string $having
  486. * @return string
  487. */
  488. 정적 함수parseHaving($having) {
  489. $havingStr = '';
  490. if(is_string($having) && !empty($having))
  491. $havingStr .= ' HAVING '.$having;
  492. return $havingStr;
  493. }
  494. /**
  495. * 필드 분할
  496. * @access 함수
  497. * @param 혼합 $필드
  498. * @return 문자열
  499. */
  500. function parseFields($fields) {
  501. if(is_array($fields)) {
  502. array_walk($fields, array($this, 'addSpecialChar'));
  503. $fieldsStr = implode(',', $fields);
  504. }else if(is_string($fields) && !empty($fields)) {
  505. if( false === strpos($fields,'`') ) {
  506. $fields =explode(',',$fields);
  507. array_walk($fields, array($this, 'addSpecialChar'));
  508. $fieldsStr = implode(',', $fields );
  509. }else {
  510. $fieldsStr = $fields;
  511. }
  512. }else $fieldsStr = '*';
  513. return $fieldsStr;
  514. }
  515. /**
  516. * 데이터 업데이트 시 호출되는 분석 설정
  517. * @access 함수
  518. * @param 혼합 $값 ​​
  519. * @return 문자열
  520. */
  521. 비공개 함수 parseSets($sets) {
  522. $setsStr = '';
  523. if(is_array($sets)){
  524. foreach ($sets as $key=> $val){
  525. $key = self::addSpecialChar($key);
  526. $val = self::fieldFormat($val);
  527. $setsStr .= "$key = ".$val. ",";
  528. }
  529. $setsStr = substr($setsStr,0,-1);
  530. }else if(is_string($sets)) {
  531. $setsStr = $sets;
  532. }
  533. return $setsStr;
  534. }
  535. /**
  536. * 필드 서식 지정
  537. * @access 함수
  538. * @param 혼합 $value
  539. * @return 혼합
  540. */
  541. 정적 함수 fieldFormat(&$value) {
  542. if(is_int($value)) {
  543. $value = intval($value);
  544. } else if(is_float($value)) {
  545. $value = floatval($value);
  546. } elseif(preg_match('/^(w* ( |-|*|/)?w*)$/i',$value)){
  547. // 支持在字段的值里face直接使用其它字段
  548. // 例如 (점수 1) (이름)必须包含括号
  549. $value = $value;
  550. }else if(is_string($value)) {
  551. $value = '''.self::escape_string($value).''';
  552. }
  553. return $value;
  554. }
  555. /**
  556. *
  557. 에 따라 필드 및 테이블 이름에 ` 추가* 지침에 사용된 키워드가 mysql에 대해 올바른지 확인
  558. * @access 함수
  559. * @param 혼합 $값
  560. * @return 혼합
  561. */
  562. 정적 함수 addSpecialChar(&$value) {
  563. if( '*' == $value | | false !== strpos($value,'(') || false !== strpos($value,'.') || false !== strpos($value,'`')) {
  564. //如果包含* 或者 使用了sql方法 则不작处理
  565. } elseif(false === strpos($value,'`') ) {
  566. $value = '`'.trim($value).'` ';
  567. }
  568. return $value;
  569. }
  570. /**
  571. ---------------------------------- ----------
  572. * 빈 요소 제거
  573. ------------- ---- ------------
  574. * @access 함수
  575. ---------- ----- ----------------
  576. * @param 혼합 $ 값
  577. ---------------------------- ----- -------------
  578. * @return 혼합
  579. ---------- ---- -----------------
  580. */
  581. 정적 함수 RemoveEmpty($value){
  582. return !empty($value);
  583. }
  584. /**
  585. * 주로 SELECT, SHOW 및 기타 명령에 대한 쿼리 실행
  586. * @access 함수
  587. * @param string $sql sql 명령
  588. * @return 혼합
  589. */
  590. 정적 함수 쿼리($sql='') {
  591. // 获取数据库联接
  592. $link = self::$link;
  593. if ( !$link ) return false;
  594. self::$queryStr = $sql;
  595. //释放前次的查询结果
  596. if ( !empty(self::$PDOStatement) ) self ::free();
  597. self::$PDOStatement = $link->prepare(self::$queryStr);
  598. $bol = self::$PDOStatement->execute();
  599. // 有错误则抛 Out异常
  600. self::haveErrorThrowException();
  601. return $bol;
  602. }
  603. /**
  604. * 데이터베이스 연산 방식
  605. * @access 함수
  606. * @param string $sql 실행문
  607. * @param boolean $lock 잠금 여부(기본값은 잠겨 있지 않음)
  608. * @return void
  609. 공용 함수 실행($sql='',$lock=false) {
  610. if(empty($sql)) $sql = $this->queryStr
  611. return $this->_execute; ($SQL)
  612. }*/
  613. /**
  614. * INSERT, UPDATE, DELETE 실행문
  615. * @access 함수
  616. * @param string $sql sql 명령
  617. * @return 정수
  618. * /
  619. 정적 함수 실행($sql='') {
  620. // 获取数据库联接
  621. $link = self::$link;
  622. if ( !$link ) return false;
  623. self::$queryStr = $sql;
  624. //释放前次的查询结果
  625. if ( !empty(self::$PDOStatement) ) self::free();
  626. $result = $link ->exec(self::$queryStr);
  627. // 있음 false;
  628. } else {
  629. self::$numRows = $result;
  630. self::$lastInsertId = $link->lastInsertId();
  631. return self::$numRows;
  632. }
  633. }
  634. /**
  635. * 데이터베이스 변경 작업인지 여부
  636. * @access private
  637. * @param string $query SQL 명령
  638. * @return boolen 쿼리 작업인 경우 false 반환
  639. */
  640. 정적 함수 isMainIps($query) {
  641. $queryIps = 'INSERT|UPDATE|DELETE|REPLACE|CREATE|DROP|LOAD DATA|SELECT .* INTO|COPY |ALTER|GRANT|REVOKE|LOCK|UNLOCK';
  642. if (preg_match('/^s*"?(' . $queryIps . ')s /i', $query)) {
  643. true를 반환합니다.
  644. }
  645. false 반환;
  646. }
  647. /**
  648. * POST 제출 데이터 필터링
  649. * @access private
  650. * @param 혼합 $data POST 제출 데이터
  651. * @param string $table 데이터 테이블 이름
  652. * @return 혼합 $newdata
  653. */
  654. 정적 함수 filterPost($table,$data) {
  655. $table_column = self::getFields( $table);
  656. $newdata=array();
  657. foreach($table_column as $key=>$val){
  658. if(array_key_exists($key,$data) && ($data[$ 키])!==''){
  659. $newdata[$key] = $data[$key];
  660. }
  661. }
  662. return $newdata;
  663. }
  664. / **
  665. * 거래 시작
  666. * @access 함수
  667. * @return void
  668. */
  669. 정적 함수 startTrans() {
  670. //数据rollback 支持
  671. $link = self::$link;
  672. if ( !$link ) return false;
  673. if (self::$transTimes == 0) {
  674. $link->beginTransaction();
  675. }
  676. self::$transTimes ;
  677. return ;
  678. }
  679. /**
  680. * 비자동 제출 상태에서 쿼리 제출에 사용됩니다.
  681. * @access 함수
  682. * @return boolen
  683. */
  684. 정적 함수 커밋() {
  685. $link = self::$link;
  686. if ( !$link ) return false;
  687. if (self::$ transTimes > 0) {
  688. $result = $link->commit();
  689. self::$transTimes = 0;
  690. if(!$result){
  691. self::throw_Exception( self::$error());
  692. false 반환;
  693. }
  694. }
  695. true 반환;
  696. }
  697. /**
  698. * 트랜잭션 롤백
  699. * @access 함수
  700. * @return bolen
  701. */
  702. 공개 함수 롤백 () {
  703. $link = self::$link;
  704. if ( !$link ) return false;
  705. if (self::$transTimes > 0) {
  706. $result = $link->rollback();
  707. self::$transTimes = 0;
  708. if(!$result){
  709. self::throw_Exception(self:: $error());
  710. false 반환;
  711. }
  712. }
  713. true 반환;
  714. }

  715. /**

  716. * 오류 처리
  717. * @access 함수
  718. * @return void
  719. */
  720. 정적 함수 throw_Exception($err){
  721. echo '
    오류:'.$err.'
    ';
  722. }
  723. }

复代码


성명：
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
이전 기사：IT 튜토리얼 공유~! PHP/Linux/html/JS/모바일 게임 개발/MySQL/기타 튜토리얼다음 기사：IT 튜토리얼 공유~! PHP/Linux/html/JS/모바일 게임 개발/MySQL/기타 튜토리얼

관련 기사

더보기