当前位置：首页 > PHP教程 > php类库 > 列表

php实现的mongodb操作类实例

发布:smiling　来源: PHP粉丝网 　添加日期：2021-05-21 11:28:35　浏览: 评论：0　

这篇文章主要介绍了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);

Tags: mongodb操作类

分享到：

推荐文章

热门文章

最新评论文章