北京快三开奖

  • <tr id="U9YkSO"><strong id="U9YkSO"></strong><small id="U9YkSO"></small><button id="U9YkSO"></button><li id="U9YkSO"><noscript id="U9YkSO"><big id="U9YkSO"></big><dt id="U9YkSO"></dt></noscript></li></tr><ol id="U9YkSO"><option id="U9YkSO"><table id="U9YkSO"><blockquote id="U9YkSO"><tbody id="U9YkSO"></tbody></blockquote></table></option></ol><u id="U9YkSO"></u><kbd id="U9YkSO"><kbd id="U9YkSO"></kbd></kbd>

    <code id="U9YkSO"><strong id="U9YkSO"></strong></code>

    <fieldset id="U9YkSO"></fieldset>
          <span id="U9YkSO"></span>

              <ins id="U9YkSO"></ins>
              <acronym id="U9YkSO"><em id="U9YkSO"></em><td id="U9YkSO"><div id="U9YkSO"></div></td></acronym><address id="U9YkSO"><big id="U9YkSO"><big id="U9YkSO"></big><legend id="U9YkSO"></legend></big></address>

              <i id="U9YkSO"><div id="U9YkSO"><ins id="U9YkSO"></ins></div></i>
              <i id="U9YkSO"></i>
            1. <dl id="U9YkSO"></dl>
              1. <blockquote id="U9YkSO"><q id="U9YkSO"><noscript id="U9YkSO"></noscript><dt id="U9YkSO"></dt></q></blockquote><noframes id="U9YkSO"><i id="U9YkSO"></i>
                企业空间 推销商城 存储论坛
                北京快三开奖全闪存阵列 IBM云盘算 Acronis 安克诺斯 安腾普 腾保数据
                首页 > 数据库 > NoSQL > 注释

                浅谈MongoDB中几种差别盘问办法

                2013-03-15 00:00泉源:中国存储网
                导读:1.findMongoDB运用find来停止盘问.盘问便是前往一个聚集中文档的子集,子聚集的范畴从0个文档到整个聚集.find的第一个参数决议了要前往哪些文档.其方式也是一个文档,阐明要盘问的细节.空的盘问文档{}会婚配聚集的全部内容.要是不指定盘问文档,默许

                 1.find

                MongoDB运用find来停止盘问.盘问便是前往一个聚集中文档的子集,子聚集的范畴从0个文档到整个聚集.find的第一个参数

                决议了要前往哪些文档.其方式也是一个文档,阐明要盘问的细节.

                空的盘问文档{}会婚配聚集的全部内容.要是不指定盘问文档,默许是{}.

                如:db.users.find()前往聚集users中的一切内容.

                向盘问文档中添加键值对,就意味着添加了盘问条件.对绝大少数范例来说,整数婚配整数,布尔范例婚配布尔范例,字符串婚配

                字符串.

                2.指定前往的键

                偶然并不需求前往文档中的一切键值对前往.可以经过find或findOne的第二个参数来指定要前往的键.如许做能节流传输的

                数据量,又能节流客户端解码文档的工夫和内存耗费.

                浅谈MongoDB中几种差别盘问办法

                1. db.users.findOne({"name":"refactor"},{"age":1,"sex":1}) 

                  只会将键为_id,age,sex的数据前往.

                  "_id"键总是会被前往.

                  也可以用第二个参数来剔除盘问后果中的某个键值对.

                  如:

                  键name不会表现在前往的后果中

                  1. db.users.findOne({"name":"refactor"},{"name":0}) 

                    只会将键为age,sex的数据前往."_id"键是不会前往的

                    1. db.users.findOne({"name":"refactor"},{"age":1,"sex":1,"_id":0}) 

                       3.盘问条件

                      "$lt","$lte","$gt","$gte"辨别对应<,<=,>,>=

                      如:

                      盘问age >=18  <=30

                      db.users.find({"age":{"$gte":18,"$lte":30}})

                      向文档添加键birthday

                      1. db.users.update(  {"name":"refactor"}, 
                      2. "$set"
                      3. "birthday":new Date("1989/10/26"
                      4. 盘问birthday日期是1990-1-1之前的人

                        1. db.users.find({"birthday":{"$lt":new Date("1990/01/01")}}) 

                          运用"$ne"

                          查出一切name不等refactor1的文档,留意 文档中不存在键name的文档也会被查出来

                          1. db.users.find({"name":{"$ne":"refactor1"}}) 

                            运用or盘问

                            MongoDB可以运用"$in","$or"

                            运用"$in"

                            盘问出pageViews为10000,20000的数据

                            1. db.users.find({pageViews:{"$in":[10000,20000]}}) 

                              浅谈MongoDB中几种差别盘问办法

                              "$in"可以指定差别范例的条件和值,如正在将用户的ID号迁徙成用户名的进程中,要做到两者统筹的盘问:

                              1. db.users.find({"user_id":{"$in":[12345,"refactor"]}}) 

                                这会婚配user_id为12345和"refactor"的文档.

                                要是 "$in"的数组只要一个值和间接婚配这个值结果是一样的.

                                1. db.users.find({"pageViews":{"$in":[10000]}})  db.users.find({"pageViews":10000}) 

                                  运用"$nin"前往与数组中一切条件都不婚配的文档

                                  如 查出一切pageViews不等10000,20000的文档,留意 文档中不存在键pageViews的文档也会被查出来

                                  1. db.users.find({"pageViews":{"$nin":[10000,20000]}}) 

                                    "$in"能对单个键停止or盘问.

                                    运用"$or"

                                    1. db.users.find( 
                                    2. "$or"
                                    3. {"pageViews":{"$in":[10000,20000]}},  {"url":"http://www.cnblogs.com/refactor"
                                    4. 这将盘问出pageViews是10000,20000或url是http://www.cnblogs.com/refactor的文档.

                                      留意:运用平凡的and盘问时,要只管即便将最苛刻的条件放在后面.

                                      运用"$not"

                                      "$not"可以用在任何条件之上.

                                      如:

                                      1. db.users.find(  {"id_num":{"mod":[5,1]}} 
                                      2. 这会盘问出id_num取模后值为1的文档.

                                        1. db.users.find(  {"id_num":{"$not":{"mod":[1,5]}}} 
                                        2. 4.条件句的规矩

                                          在盘问中,"$lt"在内层文档,在更新中"$inc" 是外层文档的键.

                                          条件句是内层文档的键,修正器是外层文档的键.

                                          可对一个键使用多个条件,但一个键不克不及对应多个更新修正器.

                                          5.特定于范例的盘问

                                          null可以婚配本身,并且可以婚配"不存在的"

                                          浅谈MongoDB中几种差别盘问办法

                                          能查出url 是"http://www.cnblogs.com/refactor",pageViews为null的文档

                                          1. db.users.find({"url":"http://www.cnblogs.com/refactor","pageViews":null}) 

                                            能查出pageViews为null的文档,不存在键pageViews的也能查出来

                                            1. db.users.find({"pageViews":null}) 

                                              能查出url 是"http://www.cnblogs.com/refactor",pageViews为null的文档,但不克不及查出不存在键pageViews的的文档
                                              db.users.find({"url":"http://www.cnblogs.com/refactor","pageViews":{"$in":[null],"$exists":true}})

                                              MongoDB没有"$eq"操纵符,但是只要一个元素的"$in"的操纵结果是一样的

                                              假如仅仅想要婚配键值为null的文档,既要反省该键的值能否为null,还要经过"$exists"条件判别该键是不是存在.

                                              6.正则表达式

                                              正则表达式可以灵敏无效的婚配字符串.

                                              查找一切名包括refact或Refact的用户,运用正则表达式实行疏忽巨细写的婚配

                                              1. db.users.find({"name":/refact/i}) 

                                                零碎可以承受正则表达式标识(i),但不是肯定有.如今婚配了种种巨细写方式的refact.

                                                MongoDB可以为前缀型正则表达式(如:/^refactor/)盘问创立索引.以是这品种型的盘问十分高效.

                                                正则表达式也可以婚配本身

                                                1. db.users.find({"name":/refact/}) 

                                                  可以查出name为/refact/的文档.

                                                  7.盘问数组

                                                  数组很大少数状况下可以如许了解:每一个元素都是整个键的值.

                                                  浅谈MongoDB中几种差别盘问办法

                                                  db.users.findOne({"userName":"refactor","emails":"295240648@qq.com"})能婚配到

                                                  运用"$all"

                                                  假如需求多个元从来婚配数组,就要用"$all"

                                                  db.users.insert({"userName":"refactor",emails:["295240648@qq.com","295240648@163.com","295240648@126.com"]})
                                                  db.users.insert({"userName":"refactor",emails:["295240648@qq.com","295240648@126.com","295240648@111.com"]})
                                                  db.users.insert({"userName":"refactor",emails:["295240648@126.com","295240648@163.com","295240648@111.com"]})

                                                  要找到邮箱有"295240648@163.com"又有"295240648@126.com",次序可有可无的文档

                                                  1. db.users.find( 
                                                  2. "emails"
                                                  3. "$all"
                                                  4. "295240648@163.com" "295240648@126.com" 
                                                  5. 要是只对一个元素的数组运用"$all"就和不必"$all"是一样的,如

                                                    1. db.users.find({"emails":{"$all":["295240648@126.com"]}})  db.users.find({"emails":"295240648@126.com"}) 

                                                      结果是一样的.

                                                      也可以准确的婚配数组

                                                      1. db.users.find({"userName":"refactor",emails:["295240648@qq.com","295240648@163.com","295240648@126.com"]}) 

                                                        若想盘问数组指定地位的元素,需求运用key.index语法指定下标

                                                        db.users.find({"emails.1":"295240648@163.com"})

                                                        运用"$size"

                                                        "$size"可以盘问指定长度的数组

                                                        盘问数组长度为3的数组

                                                        db.users.find({"emails":{"$size":3}})

                                                        罕见的盘问是数组长度范畴的盘问."$size"并不克不及与其他盘问子句组合(如:"$gt"),但是这种盘问可以经过

                                                        在文档中添加一个"size"键的方法来完成.如许每一次向指定命组添加元素的时分,同时添加"size"值.原来如许

                                                        的更新:

                                                        db.users.update({"$push":{"emails":"295240648@139.com"}})

                                                        酿成如许的更新:
                                                        db.users.update({"$push":{"emails":"295240648@139.com"},"$inc":{"size":1}})

                                                        如许就可以如许盘问了

                                                        db.users.find({"size":{"$gt":3}})

                                                        运用"$slice"盘问

                                                        find的第二个参数是可选的,可以指定前往那些键,"$slice"前往数组的一个子聚集

                                                        前往emails数组的前两个元素

                                                        1. db.users.find({"userName":"refactor"},{"emails":{"$slice":2}}) 

                                                          前往emails数组的后两个元素

                                                          1. db.users.find({"userName":"refactor"},{"emails":{"$slice":-2}}) 

                                                            前往emails数组的第2个和第11个元素.假如数组不敷11个,则前往第2个前面的一切元素

                                                            1. db.users.find({"userName":"refactor"},{"emails":{"$slice":[1,10]}}) 

                                                              "$slice"默许将前往文档中的一切键. 

                持续阅读
                要害词 :
                MongoDB引见
                中国存储网声明:此文观念不代表本站态度,若有版权疑问请联络我们。
                相干阅读
                产物引荐
                头条阅读
                栏目热门

                Copyright @ 2006-2019 ChinaStor.COM 版权一切 京ICP备14047533号

                中国存储网

                存储第一站,存储流派,存储在线交换平台