php实现的mongodb操作类实例

这篇文章主要介绍了php实现的mongodb操作类,较为详细的分析了php针对mongodb数据库操作的各种常用技巧,并将其封装进一个完整的类文件中以便于调用,非常具有实用价值,需要的朋友可以参考下

本文实例讲述了php实现的mongodb操作类。分享给大家供大家参考。具体如下：

1. <?php  
2. /* 
3. * To change this template, choose Tools | Templates 
4. * and open the template in the editor. 
5. */ 
6. class mongo_db {  
7. private $config;  
8. private $connection;  
9. private $db;  
10. private $connection_string;  
11. private $host;  
12. private $port;  
13. private $user;  
14. private $pass;  
15. private $dbname;  
16. private $persist;  
17. private $persist_key;  
18. private $selects = array();  
19. private $wheres = array();  
20. private $sorts = array();  
21. private $limit = 999999;  
22. private $offset = 0;  
23. private $timeout = 200;  
24. private $key = 0;  
25. /** 
26. * 
27. * CONSTRUCTOR * 
28. * 
29. * Automatically check if the Mongo PECL extension has been 
30. installed/enabled. 
31. * Generate the connection string and establish a connection 
32. to the MongoDB. 
33. */ 
34. public function __construct() {  
35. if((IS_NOSQL != 1)){  
36. return;  
37. }  
38. if (!class_exists('Mongo')) {  
39. //$this->error("The MongoDB PECL extension has not been installed or enabled", 500);  
40. }  
41. $configs =wxcity_base::load_config("cache","mongo_db");  
42. $num = count($configs['connect']);  
43. $this->timeout = trim($configs['timeout']);  
44. $keys = wxcity_base::load_config('double');  
45. $this->key = $keys['mongo_db'];  
46. $this->config = $configs['connect'][$this->key];  
47. $status = $this->connect();  
48. if($status == false)  
49. {  
50. for($i = 1; $i < $num; $i++)  
51. {  
52. $n = $this->key + $i;  
53. $key = $n >= $num ? $n - $num : $n;  
54. $this->config = $configs['connect'][$key];  
55. $status = $this->connect();  
56. if($status!=false)  
57. {  
58. $keys['mongo_db'] = $key ;  
59. $this->key = $key;  
60. $data = "<?php/nreturn ".var_export($keys, true).";/n?>";  
61. file_put_contents(WHTY_PATH.'configs/double.php', $data, LOCK_EX);  
62. break;  
63. }  
64. }  
65. }  
66. if($status==false)  
67. {  
68. die('mongoDB not connect');  
69. }  
70. }  
71. function __destruct() {  
72. if((IS_NOSQL != 1)){  
73. return;  
74. }  
75. if($this->connection)  
76. {  
77. $this->connection->close();  
78. }  
79. }  
80. /** 
81. * 
82. * CONNECT TO MONGODB * 
83. * 
84. * Establish a connection to MongoDB using 
85. the connection string generated in 
86. * the connection_string() method. 
87. If 'mongo_persist_key' was set to true in the  
88. * config file, establish a persistent connection. 
89. We allow for only the 'persist' 
90. * option to be set because we want to  
91. establish a connection immediately. 
92. */ 
93. private function connect() {  
94. $this->connection_string();  
95. $options = array('connect'=>true,'timeout'=>$this->timeout);  
96. try {  
97. $this->connection = new Mongo($this->connection_string, $options);  
98. $this->db = $this->connection->{$this->dbname};  
99. return($this);  
100. } catch (MongoConnectionException $e) {  
101. return false;  
102. }  
103. }  
104. /** 
105. * 
106. * BUILD CONNECTION STRING * 
107. * 
108. * Build the connection string from the config file. 
109. */ 
110. private function connection_string() {  
111. $this->host = trim($this->config['hostname']);  
112. $this->port = trim($this->config['port']);  
113. $this->user = trim($this->config['username']);  
114. $this->pass = trim($this->config['password']);  
115. $this->dbname = trim($this->config['database']);  
116. $this->persist = trim($this->config['autoconnect']);  
117. $this->persist_key = trim($this->config['mongo_persist_key']);  
118. $connection_string = "mongodb://";  
119. if (emptyempty($this->host)) {  
120. $this->error("The Host must be set to connect to MongoDB", 500);  
121. } if (emptyempty($this->dbname)) {  
122. $this->error("The Database must be set to connect to MongoDB", 500);  
123. } if (!emptyempty($this->user) && !emptyempty($this->pass)) {  
124. $connection_string .= "{$this->user}:{$this->pass}@";  
125. } if (isset($this->port) && !emptyempty($this->port)) {  
126. $connection_string .= "{$this->host}:{$this->port}";  
127. } else {  
128. $connection_string .= "{$this->host}";  
129. } $this->connection_string = trim($connection_string);  
130. }  
131. /** 
132. * 
133. * Switch_db * 
134. * 
135. * Switch from default database to a different db 
136. */ 
137. public function switch_db($database = '') {  
138. if (emptyempty($database)) {  
139. $this->error("To switch MongoDB databases, a new database name must be specified", 500);  
140. } $this->dbname = $database;  
141. try {  
142. $this->db = $this->connection->{$this->dbname};  
143. return(TRUE);  
144. } catch (Exception $e) {  
145. $this->error("Unable to switch Mongo Databases: {$e->getMessage()}", 500);  
146. }  
147. }  
148. /** 
149. * 
150. * SELECT FIELDS * 
151. * 
152. * Determine which fields to include OR which to 
153. exclude during the query process. 
154. * Currently, including and excluding at  
155. the same time is not available, so the 
156. * $includes array will take precedence over 
157. the $excludes array. 
158. If you want to 
159. * only choose fields to exclude, 
160. leave $includes an empty array(). 
161. * 
162. * @usage: $this->mongo_db->select(array('foo', 'bar'))->get('foobar'); 
163. */ 
164. public function select($includes = array(), $excludes = array()) {  
165. if (!is_array($includes)) {  
166. $includes = array();  
167. }  
168. if (!is_array($excludes)) {  
169. $excludes = array();  
170. }  
171. if (!emptyempty($includes)) {  
172. foreach ($includes as $col) {  
173. $this->selects[$col] = 1;  
174. }  
175. } else {  
176. foreach ($excludes as $col) {  
177. $this->selects[$col] = 0;  
178. }  
179. } return($this);  
180. }  
181. /** 
182. * 
183. * WHERE PARAMETERS * 
184. * 
185. * Get the documents based on these 
186. search parameters. The $wheres array should 
187. * be an associative array with the field  
188. as the key and the value as the search 
189. * criteria. * 
190. * @usage = $this->mongo_db->where(array('foo' => 'bar'))->get('foobar'); 
191. */ 
192. public function where($wheres = array()) {  
193. foreach ((array)$wheres as $wh => $val) {  
194. $this->wheres[$wh] = $val;  
195. } return($this);  
196. }  
197. /** 
198. * 
199. * WHERE_IN PARAMETERS * 
200. * 
201. * Get the documents where the value  
202. of a $field is in a given $in array(). 
203. * 
204. * @usage = $this->mongo_db->where_in('foo', array('bar', 'zoo', 'blah'))->get('foobar'); 
205. */ 
206. public function where_in($field = "", $in = array()) {  
207. $this->where_init($field);  
208. $this->wheres[$field]['$in'] = $in;  
209. return($this);  
210. }  
211. /** 
212. * 
213. * WHERE_NOT_IN PARAMETERS * 
214. * 
215. * Get the documents where the value of  
216. a $field is not in a given $in array(). 
217. * 
218. * @usage = $this->mongo_db->where_not_in('foo', array('bar', 'zoo', 'blah'))->get('foobar'); 
219. */ 
220. public function where_not_in($field = "", $in = array()) {  
221. $this->where_init($field);  
222. $this->wheres[$field]['$nin'] = $in;  
223. return($this);  
224. }  
225. /** 
226. * 
227. * WHERE GREATER THAN PARAMETERS * 
228. * 
229. * Get the documents where the value of  
230. a $field is greater than $x 
231. *  
232. * @usage = $this->mongo_db->where_gt('foo', 20); 
233. */ 
234. public function where_gt($field = "", $x) {  
235. $this->where_init($field);  
236. $this->wheres[$field]['$gt'] = $x;  
237. return($this);  
238. }  
239. /** 
240. * 
241. * WHERE GREATER THAN OR EQUAL TO PARAMETERS * 
242. * 
243. * Get the documents where the value of a $field is greater than or equal to $x 
244. * 
245. * @usage = $this->mongo_db->where_gte('foo', 20); 
246. */ 
247. public function where_gte($field = "", $x) {  
248. $this->where_init($field);  
249. $this->wheres[$field]['$gte'] = $x;  
250. return($this);  
251. }  
252. /** 
253. * 
254. * WHERE LESS THAN PARAMETERS * 
255. * 
256. * Get the documents where the value of 
257. a $field is less than $x 
258. * 
259. * @usage = $this->mongo_db->where_lt('foo', 20); 
260. */ 
261. public function where_lt($field = "", $x) {  
262. $this->where_init($field);  
263. $this->wheres[$field]['$lt'] = $x;  
264. return($this);  
265. }  
266. /** 
267. * 
268. * WHERE LESS THAN OR EQUAL TO PARAMETERS * 
269. * 
270. * Get the documents where the value of  
271. a $field is less than or equal to $x 
272. * 
273. * @usage = $this->mongo_db->where_lte('foo', 20); 
274. */ 
275. public function where_lte($field = "", $x) {  
276. $this->where_init($field);  
277. $this->wheres[$field]['$lte'] = $x;  
278. return($this);  
279. }  
280. /** 
281. * 
282. * WHERE BETWEEN PARAMETERS * 
283. * 
284. * Get the documents where the value of 
285. a $field is between $x and $y 
286. * 
287. * @usage = $this->mongo_db->where_between('foo', 20, 30); 
288. */ 
289. public function where_between($field = "", $x, $y) {  
290. $this->where_init($field);  
291. $this->wheres[$field]['$gte'] = $x;  
292. $this->wheres[$field]['$lte'] = $y;  
293. return($this);  
294. }  
295. /** 
296. * 
297. * WHERE BETWEEN AND NOT EQUAL TO PARAMETERS * 
298. * 
299. * Get the documents where the value of  
300. a $field is between but not equal to $x and $y 
301. * 
302. * @usage = $this->mongo_db->where_between_ne('foo', 20, 30); 
303. */ 
304. public function where_between_ne($field = "", $x, $y) {  
305. $this->where_init($field);  
306. $this->wheres[$field]['$gt'] = $x;  
307. $this->wheres[$field]['$lt'] = $y;  
308. return($this);  
309. }  
310. /** 
311. * 
312. * WHERE NOT EQUAL TO PARAMETERS * 
313. * 
314. * Get the documents where the value of  
315. a $field is not equal to $x 
316. * 
317. * @usage = $this->mongo_db->where_between('foo', 20, 30); 
318. */ 
319. public function where_ne($field = "", $x) {  
320. $this->where_init($field);  
321. $this->wheres[$field]['$ne'] = $x;  
322. return($this);  
323. }  
324. /** 
325. * 
326. * WHERE OR * 
327. * 
328. * Get the documents where the value of  
329. a $field is in one or more values  
330. * 
331. * @usage = $this->mongo_db->where_or('foo', array( 'foo', 'bar', 'blegh' ); 
332. */ 
333. public function where_or($field = "", $values) {  
334. $this->where_init($field);  
335. $this->wheres[$field]['$or'] = $values;  
336. return($this);  
337. }  
338. /** 
339. * 
340. * WHERE AND * 
341. * 
342. * Get the documents where the elements match  
343. the specified values * 
344. * @usage = $this->mongo_db->where_and( array ( 'foo' => 1, 'b' => 'someexample' ); 
345. */ 
346. public function where_and($elements_values = array()) {  
347. foreach ((array)$elements_values as $element => $val) {  
348. $this->wheres[$element] = $val;  
349. } return($this);  
350. }  
351. /** 
352. * 
353. * WHERE MOD * 
354. * 
355. * Get the documents where $field % $mod = $result * 
356. * @usage = $this->mongo_db->where_mod( 'foo', 10, 1 ); 
357. */ 
358. public function where_mod($field, $num, $result) {  
359. $this->where_init($field);  
360. $this->wheres[$field]['$mod'] = array($num, $result);  
361. return($this);  
362. }  
363. /** * * Where size * * * Get the documents where the size of a field is in a given $size int * * @usage : $this->mongo_db->where_size('foo', 1)->get('foobar'); */ 
364. public function where_size($field = "", $size = "") {  
365. $this->_where_init($field);  
366. $this->wheres[$field]['$size'] = $size;  
367. return ($this);  
368. }  
369. /** 
370. * 
371. * LIKE PARAMETERS * 
372. * 
373. * Get the documents where the (string) value of  
374. a $field is like a value. The defaults 
375. * allow for a case-insensitive search. * 
376. * @param $flags  
377. * Allows for the typical regular expression flags: 
378. * i = case insensitive 
379. * m = multiline 
380. * x = can contain comments 
381. * l = locale  
382. * s = dotall, "." matches everything, including newlines 
383. * u = match unicode 
384. * 
385. * @param $enable_start_wildcard 
386. * If set to anything other than TRUE, a starting line character "^" will be prepended 
387. * to the search value, representing only searching for a value at the start of 
388. * a new line. 
389. * * @param $enable_end_wildcard  
390. * If set to anything other than TRUE, an ending line character "$" will be appended 
391. * to the search value, representing only searching for a value at the end of 
392. * a line. 
393. *  
394. * @usage = $this->mongo_db->like('foo', 'bar', 'im', FALSE, TRUE); 
395. */ 
396. public function like($field = "", $value = "", $flags = "i", $enable_start_wildcard = TRUE, $enable_end_wildcard = TRUE) {  
397. $field = (string) trim($field);  
398. $this->where_init($field);  
399. $value = (string) trim($value);  
400. $value = quotemeta($value);  
401. if ($enable_start_wildcard !== TRUE) {  
402. $value = "^" . $value;  
403. } if ($enable_end_wildcard !== TRUE) {  
404. $value .= "$";  
405. } $regex = "/$value/$flags";  
406. $this->wheres[$field] = new MongoRegex($regex);  
407. return($this);  
408. }  
409. public function wheres($where){  
410. $this->wheres = $where;  
411. }  
412. /** 
413. * 
414. * ORDER BY PARAMETERS * 
415. * 
416. * Sort the documents based on the parameters passed. 
417. To set values to descending order, 
418. * you must pass values of either -1, FALSE, 
419. 'desc', or 'DESC', else they will be 
420. * set to 1 (ASC). 
421. * 
422. * @usage = $this->mongo_db->where_between('foo', 20, 30); 
423. */ 
424. public function order_by($fields = array()) {  
425. if (!is_array($fields) || !count($fields)) return ;  
426. foreach ($fields as $col => $val) {  
427. if ($val == -1 || $val === FALSE || strtolower($val) == 'desc') {  
428. $this->sorts[$col] = -1;  
429. } else {  
430. $this->sorts[$col] = 1;  
431. }  
432. } return($this);  
433. }  
434. /** 
435. * 
436. * LIMIT DOCUMENTS * 
437. * 
438. * Limit the result set to $x number of documents * 
439. * @usage = $this->mongo_db->limit($x); 
440. */ 
441. public function limit($x = 99999) {  
442. if ($x !== NULL && is_numeric($x) && $x >= 1) {  
443. $this->limit = (int) $x;  
444. } return($this);  
445. }  
446. /** 
447. * 
448. * OFFSET DOCUMENTS * 
449. * 
450. * Offset the result set to skip $x number of documents 
451. * 
452. * @usage = $this->mongo_db->offset($x); 
453. */ 
454. public function offset($x = 0) {  
455. if ($x !== NULL && is_numeric($x) && $x >= 1) {  
456. $this->offset = (int) $x;  
457. } return($this);  
458. }  
459. /** 
460. * 
461. * GET_WHERE * 
462. *  
463. * Get the documents based upon the passed parameters * 
464. * @usage = $this->mongo_db->get_where('foo', array('bar' => 'something')); 
465. */ 
466. public function get_where($collection = "", $where = array(), $limit = 99999, $orderby=array()) {  
467. if (is_array($orderby) || !emptyempty($orderby)) {  
468. $order_by = $this->order_by($order_by);  
469. }  
470. return($this->where($where)->limit($limit)->get($collection));  
471. }  
472. public function selectA($collection = "", $limit = 99999, $orderby=array()) {  
473. if(intval($limit)<1){  
474. $limit = 999999;  
475. }  
476. $order_by = $this->order_by($orderby);  
477. $re = $this->limit($limit)->get($collection);  
478. $this->clear();  
479. return (array)$re;  
480. }  
481. public function listinfo($collection = "", $orderby=array(), $page=1, $pagesize=12) {  
482. $page = max(intval($page), 1);  
483. $offset = $pagesize * ($page - 1);  
484. $pagesizes = $offset + $pagesize;  
485. $this->offset($offset);  
486. $order_by = $this->order_by($orderby);  
487. $re = $this->limit($pagesize)->get($collection);  
488. $this->limit(999999);  
489. $count = $this->count($collection);  
490. $this->pages = pages($count, $page, $pagesize);  
491. return (array)$re;  
492. }  
493. /** 
494. * 
495. * GET * 
496. * 
497. * Get the documents based upon the passed parameters * 
498. * @usage = $this->mongo_db->get('foo', array('bar' => 'something')); 
499. */ 
500. public function get($collection = "") {  
501. if (emptyempty($collection)) {  
502. $this->error("In order to retreive documents from MongoDB, a collection name must be passed", 500);  
503. } $results = array();  
504. $documents = $this->db->{$collection}->find($this->wheres, $this->selects)->limit((int) $this->limit)->skip((int) $this->offset)->sort($this->sorts);  
505. $returns = array();  
506. foreach ($documents as $doc): $returns[] = $doc;  
507. endforeach;  
508. return($returns);  
509. }  
510. public function getMy($collection = "") {  
511. if (emptyempty($collection)) {  
512. $this->error("In order to retreive documents from MongoDB, a collection name must be passed", 500);  
513. } $results = array();  
514. $documents = $this->db->{$collection}->find($this->wheres, $this->selects)->limit((int) $this->limit)->skip((int) $this->offset)->sort($this->sorts);  
515. $returns = array();  
516. foreach ($documents as $doc): $returns[] = $doc;  
517. endforeach;  
518. $this -> clear();  
519. return($returns);  
520. }  
521. /** 
522. * 
523. * COUNT * 
524. * 
525. * Count the documents based upon the passed parameters * 
526. * @usage = $this->mongo_db->get('foo'); 
527. */ 
528. public function count($collection = "") {  
529. if (emptyempty($collection)) {  
530. $this->error("In order to retreive a count of documents from MongoDB, a collection name must be passed", 500);  
531. } $count = $this->db->{$collection}->find($this->wheres)->limit((int) $this->limit)->skip((int) $this->offset)->count();  
532. $this->clear();  
533. return($count);  
534. }  
535. /** 
536. * 
537. * INSERT * 
538. * 
539. * Insert a new document into the passed collection * 
540. * @usage = $this->mongo_db->insert('foo', $data = array()); 
541. */ 
542. public function insert($collection = "", $data = array(), $name='ID') {  
543. if (emptyempty($collection)) {  
544. $this->error("No Mongo collection selected to insert into", 500);  
545. } if (count($data) == 0 || !is_array($data)) {  
546. $this->error("Nothing to insert into Mongo collection or insert is not an array", 500);  
547. } try {  
548. /** 
549. wxcity_base::load_sys_class('whtysqs','',0);  
550. $mongoseq_class = new whtysqs('creaseidsqs'); 
551. $re = $mongoseq_class->query("?name=" . $collection . "&opt=put&data=1"); 
552. **/ 
553. $re = put_sqs('list_mongo_creaseidsqs','1');  
554. if(is_numeric($re)){  
555. $re++;  
556. $data[$name] = intval($re);  
557. }else{  
558. $data[$name] = intval(time());  
559. //die('mongosqs error');  
560. }  
561. $this->db->{$collection}->insert($data, array('fsync' => TRUE));  
562. $this->clear();  
563. return $data[$name];  
564. } catch (MongoCursorException $e) {  
565. $this->error("Insert of data into MongoDB failed: {$e->getMessage()}", 500);  
566. }  
567. }  
568. public function insertWithId($collection = "", $data = array()) {  
569. if (emptyempty($collection)) {  
570. $this->error("No Mongo collection selected to insert into", 500);  
571. } if (count($data) == 0 || !is_array($data)) {  
572. $this->error("Nothing to insert into Mongo collection or insert is not an array", 500);  
573. } try {  
574. $this->db->{$collection}->insert($data, array('fsync' => TRUE));  
575. $this->clear();  
576. return 1;  
577. } catch (MongoCursorException $e) {  
578. $this->error("Insert of data into MongoDB failed: {$e->getMessage()}", 500);  
579. }  
580. }  
581. /** 
582. * 
583. * UPDATE * 
584. * 
585. * Update a document into the passed collection * 
586. * @usage = $this->mongo_db->update('foo', $data = array()); 
587. */ 
588. public function update($collection = "", $data = array()) {  
589. if (emptyempty($collection)) {  
590. $this->error("No Mongo collection selected to update", 500);  
591. } if (count($data) == 0 || !is_array($data)) {  
592. $this->error("Nothing to update in Mongo collection or update is not an array", 500);  
593. } try {  
594. $this->db->{$collection}->update($this->wheres, array('$set' => $data), array('fsync' => TRUE, 'multiple' => FALSE));  
595. $this->clear();  
596. return(TRUE);  
597. } catch (MongoCursorException $e) {  
598. $this->error("Update of data into MongoDB failed: {$e->getMessage()}", 500);  
599. }  
600. }  
601. /** 
602. * 
603. * UPDATE_ALL * 
604. * 
605. * Insert a new document into the passed collection * 
606. * @usage = $this->mongo_db->update_all('foo', $data = array()); 
607. */ 
608. public function update_all($collection = "", $data = array()) {  
609. if (emptyempty($collection)) {  
610. $this->error("No Mongo collection selected to update", 500);  
611. } if (count($data) == 0 || !is_array($data)) {  
612. $this->error("Nothing to update in Mongo collection or update is not an array", 500);  
613. } try {  
614. $this->db->{$collection}->update($this->wheres, array('$set' => $data), array('fsync' => TRUE, 'multiple' => TRUE));  
615. return(TRUE);  
616. } catch (MongoCursorException $e) {  
617. $this->error("Update of data into MongoDB failed: {$e->getMessage()}", 500);  
618. }  
619. }  
620. /** 
621. * 
622. * DELETE * 
623. * 
624. * delete document from the passed collection based upon certain criteria * 
625. * @usage = $this->mongo_db->delete('foo', $data = array()); 
626. */ 
627. public function delete($collection = "") {  
628. if (emptyempty($collection)) {  
629. $this->error("No Mongo collection selected to delete from", 500);  
630. } try {  
631. $this->db->{$collection}->remove($this->wheres, array('fsync' => TRUE, 'justOne' => TRUE));  
632. $this->clear();  
633. return(TRUE);  
634. } catch (MongoCursorException $e) {  
635. $this->error("Delete of data into MongoDB failed: {$e->getMessage()}", 500);  
636. }  
637. }  
638. /** 
639. * 
640. * DELETE_ALL * 
641. * 
642. * Delete all documents from the passed collection based upon certain criteria 
643. * 
644. * @usage = $this->mongo_db->delete_all('foo', $data = array()); 
645. */ 
646. public function delete_all($collection = "") {  
647. if (emptyempty($collection)) {  
648. $this->error("No Mongo collection selected to delete from", 500);  
649. } try {  
650. $this->db->{$collection}->remove($this->wheres, array('fsync' => TRUE, 'justOne' => FALSE));  
651. return(TRUE);  
652. } catch (MongoCursorException $e) {  
653. $this->error("Delete of data into MongoDB failed: {$e->getMessage()}", 500);  
654. }  
655. }  
656. /** 
657. * 
658. * ADD_INDEX * 
659. * 
660. * Ensure an index of the keys in a collection with optional parameters. 
661. To set values to descending order, 
662. * you must pass values of either -1, FALSE, 'desc', or 'DESC', else they will be 
663. * set to 1 (ASC). * 
664. * @usage = $this->mongo_db->add_index($collection, array('first_name' => 'ASC', 'last_name' => -1), array('unique' => TRUE)); 
665. */ 
666. public function add_index($collection = "", $keys = array(), $options = array()) {  
667. if (emptyempty($collection)) {  
668. $this->error("No Mongo collection specified to add index to", 500);  
669. } if (emptyempty($keys) || !is_array($keys)) {  
670. $this->error("Index could not be created to MongoDB Collection because no keys were specified", 500);  
671. } foreach ($keys as $col => $val) {  
672. if ($val == -1 || $val === FALSE || strtolower($val) == 'desc') {  
673. $keys[$col] = -1;  
674. } else {  
675. $keys[$col] = 1;  
676. }  
677. } if ($this->db->{$collection}->ensureIndex($keys, $options) == TRUE) {  
678. $this->clear();  
679. return($this);  
680. } else {  
681. $this->error("An error occured when trying to add an index to MongoDB Collection", 500);  
682. }  
683. }  
684. /** 
685. * 
686. * REMOVE_INDEX * 
687. * 
688. * Remove an index of the keys in a collection. 
689. To set values to descending order, 
690. * you must pass values of either -1, FALSE, 'desc', or 'DESC', else they will be 
691. * set to 1 (ASC). * 
692. * @usage = $this->mongo_db->remove_index($collection, array('first_name' => 'ASC', 'last_name' => -1)); 
693. */ 
694. public function remove_index($collection = "", $keys = array()) {  
695. if (emptyempty($collection)) {  
696. $this->error("No Mongo collection specified to remove index from", 500);  
697. } if (emptyempty($keys) || !is_array($keys)) {  
698. $this->error("Index could not be removed from MongoDB Collection because no keys were specified", 500);  
699. } if ($this->db->{$collection}->deleteIndex($keys, $options) == TRUE) {  
700. $this->clear();  
701. return($this);  
702. } else {  
703. $this->error("An error occured when trying to remove an index from MongoDB Collection", 500);  
704. }  
705. }  
706. /** 
707. * 
708. * REMOVE_ALL_INDEXES * 
709. * 
710. * Remove all indexes from a collection. * 
711. * @usage = $this->mongo_db->remove_all_index($collection); 
712. */ 
713. public function remove_all_indexes($collection = "") {  
714. if (emptyempty($collection)) {  
715. $this->error("No Mongo collection specified to remove all indexes from", 500);  
716. } $this->db->{$collection}->deleteIndexes();  
717. $this->clear();  
718. return($this);  
719. }  
720. /** 
721. * 
722. * LIST_INDEXES * 
723. * 
724. * Lists all indexes in a collection. * 
725. * @usage = $this->mongo_db->list_indexes($collection); 
726. */ 
727. public function list_indexes($collection = "") {  
728. if (emptyempty($collection)) {  
729. $this->error("No Mongo collection specified to remove all indexes from", 500);  
730. } return($this->db->{$collection}->getIndexInfo());  
731. }  
732. /** 
733. * 
734. * DROP COLLECTION * 
735. * 
736. * Removes the specified collection from the database. 
737. Be careful because this 
738. * can have some very large issues in production! 
739. */ 
740. public function drop_collection($collection = "") {  
741. if (emptyempty($collection)) {  
742. $this->error("No Mongo collection specified to drop from database", 500);  
743. } $this->db->{$collection}->drop();  
744. return TRUE;  
745. }  
746. /** 
747. * 
748. * CLEAR * 
749. * 
750. * Resets the class variables to default settings 
751. */ 
752. private function clear() {  
753. $this->selects = array();  
754. $this->wheres = array();  
755. $this->limit = NULL;  
756. $this->offset = NULL;  
757. $this->sorts = array();  
758. }  
759. /** 
760. * 
761. * WHERE INITIALIZER * 
762. * 
763. * Prepares parameters for insertion in $wheres array(). 
764. */ 
765. private function where_init($param) {  
766. if (!isset($this->wheres[$param])) {  
767. $this->wheres[$param] = array();  
768. }  
769. }  
770. public function error($str, $t) {  
771. echo $str;  
772. exit;  
773. }  
774. }  
775. ?> 

使用范例：

1. $table_name=trim(strtolower($this->table_name));  
2. $this->mongo_db->where($where);  
3. $order=!emptyempty($order)?array('AID'=>'DESC'):array('AID'=>'ASC'); 
4. //升序降序  
5. $infos=$this->mongo_db->listinfo($table_name,$order,$page,$pagesize); 

希望本文所述对大家的php程序设计有所帮助。