Home > Developer > PHP

Phppdo database operation encapsulation code

Source: Internet
Author: User
Tags pconnect
Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞
Phppdo database operation encapsulation code

  3. /**

  4. * Database PDO operations
  5. */
  6. Class MysqlPdo {
  7. Public static $ PDOStatement = null;
  8. /**
  9. * Database connection parameter configuration
  10. * @ Var array
  11. * @ Access public
  12. */
  13. Public static $ config = array ();
  14. /**
  15. * Whether to use permanent connection
  16. * @ Var bool
  17. * @ Access public
  18. */
  19. Public static $ pconnect = false;
  20. /**
  21. * Error message
  22. * @ Var string
  23. * @ Access public
  24. */
  25. Public static $ error = '';
  26. /**
  27. * In single-piece mode, the unique instance of the Pdo class is saved and the connection resource of the database is saved.
  28. * @ Var object
  29. * @ Access public
  30. */
  31. Protected static $ link;
  32. /**
  33. * Whether the database has been connected
  34. * @ Var bool
  35. * @ Access public
  36. */
  37. Public static $ connected = false;
  38. /**
  39. * Database version
  40. * @ Var string
  41. * @ Access public
  42. */
  43. Public static $ dbVersion = null;
  44. /**
  45. * Current SQL statement
  46. * @ Var string
  47. * @ Access public
  48. */
  49. Public static $ queryStr = '';
  50. /**
  51. * Last inserted record ID
  52. * @ Var integer
  53. * @ Access public
  54. */
  55. Public static $ lastInsertId = null;
  56. /**
  57. * Number of affected records returned
  58. * @ Var integer
  59. * @ Access public
  60. */
  61. Public static $ numRows = 0;
  62. // Transaction instruction count
  63. Public static $ transTimes = 0;
  64. /**
  65. * Constructor,
  66. * @ Param $ dbconfig database connection information, array ('servername', 'username', 'password', 'defaultdb', 'DB _ port', 'DB _ type ')
  67. */
  68. Public function _ construct ($ dbConfig = ''){
  69. If (! Class_exists ('pdo') self: throw_exception ("not supported: PDO ");
  70. // Use the default data definition if no parameters are transmitted
  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 ("no database configuration defined ");
  83. Self: $ config = $ dbConfig;
  84. If (empty (self: $ config ['params']) self: $ config ['params'] = array ();
  85. /************************************ Gorgeous separation line **************************************** ***/
  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. // Mark the connection successful
  103. Self: $ connected = true;
  104. // Cancel database connection configuration
  105. Unset ($ configs );
  106. }
  107. Return self: $ link;
  108. }
  109. /**
  110. * Release query results
  111. * @ Access function
  112. */
  113. Static function free (){
  114. Self: $ PDOStatement = null;
  115. }
  116. /************************/
  117. /* Database operations */
  118. /************************/
  119. /**
  120. * Obtain all query data
  121. * @ Access function
  122. * @ Return array
  123. */
  124. Static function getAll ($ SQL = null ){
  125. If ($ SQL! = Null)
  126. {
  127. Self: query ($ SQL );
  128. }
  129. // Return the dataset
  130. $ Result = self ::$ PDOStatement-> fetchAll (constant ('pdo: FETCH_ASSOC '));
  131. Return $ result;
  132. }
  133. /**
  134. * Obtain a query result.
  135. * @ Access function
  136. * @ Param string $ SQL SQL command
  137. * @ Param integer $ seek pointer position
  138. * @ Return array
  139. */
  140. Static function getRow ($ SQL = null ){
  141. If ($ SQL! = Null)
  142. {
  143. Self: query ($ SQL );
  144. }
  145. // Returns the array set.
  146. $ Result = self ::$ PDOStatement-> fetch (constant ('pdo: FETCH_ASSOC '), constant ('pdo: FETCH_ORI_NEXT '));
  147. Return $ result;
  148. }
  149. /**
  150. * Execute SQL statements to automatically query or execute operations.
  151. * @ Access function
  152. * @ Param string $ SQL SQL command
  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. * Query table records based on the specified ID (for single table operations only)
  164. * @ Access function
  165. * @ Param integer $ priId primary key ID
  166. * @ Param string $ tables data table name
  167. * @ Param string $ fields field name
  168. * @ Return ArrayObject table record
  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. * Query records
  176. * @ Access function
  177. * @ Param string $ tables data table name
  178. * @ Param mixed $ where query condition
  179. * @ Param string $ fields field name
  180. * @ Param string $ order sorting
  181. * @ Param string $ limit: how many data records are Retrieved?
  182. * @ Param string $ group
  183. * @ Param string $ having
  184. * @ Param boolean $ whether lock is locked
  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. * Insert (single) records
  201. * @ Access function
  202. * @ Param mixed $ data
  203. * @ Param string $ table data table name
  204. * @ Return false | integer
  205. */
  206. Function add ($ data, $ table ){
  207. // Filter submitted data
  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]; // use the expression ???
  212. } Elseif (is_scalar ($ val )){
  213. $ Val = self: fieldFormat ($ val );
  214. } Else {
  215. // Remove the composite object
  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'. $ table. '('. $ fieldsStr. ') VALUES ('. $ valuesStr .')';
  226. Return self: execute ($ SQL );
  227. }
  228. /**
  229. * Update records
  230. * @ Access function
  231. * @ Param mixed $ sets Data
  232. * @ Param string $ table data table name
  233. * @ Param string $ where update condition
  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. * Save the value of a field
  245. * @ Access function
  246. * @ Param string $ field name of the field to be saved
  247. * @ Param string $ value field value
  248. * @ Param string $ table data table
  249. * @ Param string $ where save condition
  250. * @ Param boolean $ asString whether the field value is a string
  251. * @ Return void
  252. */
  253. Static function setField ($ field, $ value, $ table, $ condition = "", $ asString = false ){
  254. // If '(' is regarded as an SQL command update; otherwise, the field content is updated as a pure string.
  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. * Delete a record
  261. * @ Access function
  262. * @ Param mixed $ where is the condition Map, Array, or String.
  263. * @ Param string $ table data table name
  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. * Modify or save data (for single table operations only)
  275. * If there is a primary key ID, it is modified. if there is no primary key ID, it is added.
  276. * Modification record:
  277. + ----------------------------------------------------------
  278. * @ Access function
  279. + ----------------------------------------------------------
  280. * @ Param $ tabName table name
  281. * @ Param $ _ POST of the form submitted by aPost
  282. * @ Param $ priId primary key ID
  283. * @ Param $ aNot the field or array to be excluded
  284. * @ Param $ aCustom a custom array, which is appended to the database and saved
  285. * @ Param $ whether isExits already exists: true, not exist: false
  286. + ----------------------------------------------------------
  287. * @ Return Boolean whether modification or saving is successful
  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) {// add
  296. $ APost = array_filter ($ aPost, array ($ this, 'removeempty '));
  297. Return self: add ($ aPost, $ tabName );
  298. } Else {// modify
  299. Return self: update ($ aPost, $ tabName, "id =". $ priId );
  300. }
  301. }
  302. /**
  303. * Obtain the SQL statement of the last query
  304. * @ Access function
  305. * @ Param
  306. * @ Return String the SQL statement executed
  307. */
  308. Static function getLastSql (){
  309. $ Link = self: $ link;
  310. If (! $ Link) return false;
  311. Return self: $ queryStr;
  312. }
  313. /**
  314. * Obtain the last inserted ID.
  315. * @ Access function
  316. * @ Param
  317. * @ Return the ID of the last inserted integer
  318. */
  319. Static function getLastInsId (){
  320. $ Link = self: $ link;
  321. If (! $ Link) return false;
  322. Return self: $ lastInsertId;
  323. }
  324. /**
  325. * Obtain the database version.
  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. * Obtain database table information
  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. * Obtain the field information of the data table.
  352. * @ Access function
  353. * @ Return array
  354. */
  355. Static function getFields ($ tableName ){
  356. // Obtain the database connection
  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. $ Something = $ link-> prepare ($ SQL );
  368. $ Something-> bindParam (': tabname', $ tableName );
  369. $ Something-> execute ();
  370. $ Result = $ Something-> 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. // If an error exists, an exception is thrown.
  387. Self: haveErrorThrowException ();
  388. Return $ info;
  389. }
  390. /**
  391. * Shut down the database.
  392. * @ Access function
  393. */
  394. Static function close (){
  395. Self: $ link = null;
  396. }
  397. /**
  398. * SQL Command Security filtering
  399. * @ Access function
  400. * @ Param string $ str SQL command
  401. * @ Return string
  402. */
  403. Static function escape_string ($ str ){
  404. Return addslashes ($ str );
  405. }
  406. /************************/
  407. /* Internal operation method */
  408. /************************/
  409. /**
  410. * An error occurs and an exception is thrown.
  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]! = '000000') {// error message
  418. Self: $ error = $ arrError [0]. "|". $ arrError [2]."
    [SQL]: ". self: $ queryStr ."
    ";
  419. Self: throw_exception (self: $ error );
  420. Return false;
  421. }
  422. // Throws an exception mainly for the execute () method
  423. If (self ::$ queryStr = '') self: throw_exception ('query was empty

    [SQL statement]: ');
  424. }
  425. /**
  426. * Where analysis
  427. * @ Access function
  428. * @ Param mixed $ where query condition
  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 analysis
  440. * @ Access function
  441. * @ Param mixed $ order sorting
  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 analysis
  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 Analysis
  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 analysis
  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 analysis
  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 analysis, called when updating data
  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. * Field formatting
  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. // Other fields can be directly used in the field values
  550. // For example, (score + 1) (name) must contain parentheses
  551. $ Value = $ value;
  552. } Else if (is_string ($ value )){
  553. $ Value = '\ ''. self: escape_string ($ value ).'\'';
  554. }
  555. Return $ value;
  556. }
  557. /**
  558. * The field and table name add' match
  559. * Ensure that the keyword used in the command is correct for 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. // If it contains * or uses the SQL method, it is not processed.
  567. } Elseif (false === strpos ($ value ,''')){
  568. $ Value = '''. trim ($ value ).''';
  569. }
  570. Return $ value;
  571. }
  572. /**
  573. + ----------------------------------------------------------
  574. * Remove null elements
  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. * Query execution mainly targets SELECT, SHOW, and other commands.
  588. * @ Access function
  589. * @ Param string $ SQL command
  590. * @ Return mixed
  591. */
  592. Static function query ($ SQL = ''){
  593. // Obtain the database connection
  594. $ Link = self: $ link;
  595. If (! $ Link) return false;
  596. Self: $ queryStr = $ SQL;
  597. // Release the previous query result
  598. If (! Empty (self ::$ PDOStatement) self: free ();
  599. Self: $ PDOStatement = $ link-> prepare (self ::$ queryStr );
  600. $ Bol = self: $ PDOStatement-> execute ();
  601. // If an error exists, an exception is thrown.
  602. Self: haveErrorThrowException ();
  603. Return $ bol;
  604. }
  605. /**
  606. * Database operation method
  607. * @ Access function
  608. * @ Param string $ SQL execution statement
  609. * @ Param boolean $ whether lock is locked (not locked by default)
  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. * Execute statements for INSERT, UPDATE, and DELETE
  617. * @ Access function
  618. * @ Param string $ SQL command
  619. * @ Return integer
  620. */
  621. Static function execute ($ SQL = ''){
  622. // Obtain the database connection
  623. $ Link = self: $ link;
  624. If (! $ Link) return false;
  625. Self: $ queryStr = $ SQL;
  626. // Release the previous query result
  627. If (! Empty (self ::$ PDOStatement) self: free ();
  628. $ Result = $ link-> exec (self: $ queryStr );
  629. // If an error exists, an exception is thrown.
  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. * Whether it is a database change operation
  641. * @ Access private
  642. * @ Param string $ query SQL command
  643. * @ Return boolen returns false if it is a query operation.
  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. * Filter POST submitted data
  654. * @ Access private
  655. * @ Param mixed $ data POST submit data
  656. * @ Param string $ table data table name
  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. * Start the transaction
  671. * @ Access function
  672. * @ Return void
  673. */
  674. Static function startTrans (){
  675. // Data rollback support
  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. * Used for querying and submitting under the non-automatic submission status
  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. * Transaction rollback
  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. * Handle errors
  722. * @ Access function
  723. * @ Return void
  724. */
  725. Static function throw_exception ($ err ){
  726. Echo'

    ERROR: '. $ err .'

    ';
  727. }
  728. }

This article is an English version of an article which is originally in the Chinese language on aliyun.com and is provided for information purposes only. This website makes no representation or warranty of any kind, either expressed or implied, as to the accuracy, completeness ownership or reliability of the article or any translations thereof. If you have any concerns or complaints relating to the article, please send an email, providing a detailed description of the concern or complaint, to info-contact@alibabacloud.com. A staff member will contact you within 5 working days. Once verified, infringing content will be removed immediately.

Related Keywords:
encapsulation wiki encapsulation in net what encapsulation in net encapsulation in php php encapsulation example small item net encapsulation polymorphism vs encapsulation

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

What's Trending
Top 10 Tags
datastax versions naming convention zookeeper client class definition md5 microsoft sql server 2005 data structures exception handling error handling
Top 10 Keywords
microsoft download center down wordpress address url site address url wordpress address url windows installer 4 0 download 302 not found web address url definition site address url wordpress db2 integer mac os installation step by step pdf abbreviation for return

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

Get Started for Free

  • Sales Support

    1 on 1 presale consultation

    Chat Contact Sales

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

    Open a Ticket

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.

    Learn More