MongoDB学习8_MongoDB查询语句

文章一：

Find方法的使用

find(参数1，参数2)
参数1：需要返回的文档
参数2：指定想要的键

?

1 2 3 4 5 6 7

//查询users表中age为27的文档 db.users.find({ 'age' : 27}) //查询users表中username为joe的文档 db.users.find({ 'username' : 'joe' }) //可以使用多条件查询，会解释成条件1 AND 条件2 AND...AND 条件N //例如查询username为joe且age为27的用户 db.users.find({ 'username' : 'joe' , 'age' : 27})

• 指定返回的键,find()方法的第二个参数就是指定返回的键
  
  ?

  1 2	//提取users表中的username和email键,默认会返回_id键，所以我们在第二个参数中将其设置为0，就不会提取了。 db.users.find({},{ 'username' : 1, 'email' : 1, '_id' : 0})

查询条件

替代符	$lt	$lte	$gt	$gte	$ne
对应关系	<	<=	>	>=	!=

?

1 2 3 4

//查询年龄在18～30（含）之间的用户 db.users.find({ 'age' : {$gte : 18, $lte : 30}}) //查询不是joe的用户 db.users.find({ 'username' : {$ne : 'joe' }})

OR查询

$in可以用来查询一个键的多个值
$or用来完成多个键值的任意给定值

?

1 2 3 4 5 6 7 8 9 10

//对于单一键要是有多个值与其匹配的话，就要使用$in加一个条件数组 //例如中奖号码为725，542和390 db.raffle.find({ 'ticket_no' : { $ in : [] }}) //与$in相对应的方法是$nin db.raffle.find({ 'ticket_no' : { $nin : [725, 542, 390] }})   //$or的使用 db.raffle.find({ '$or' : [{ 'ticket_no' ：725},{ 'winner' : true }]})   //两者结合使用 <span></span> db.raffle.find({'$or' : [{'ticket_no' ：{ $in : [725, 542, 390<span></span>]}},{'winner' : true}]})

$not是元条件句，可以在任何其他条件之上

?

1 2 3 4 5

//$mod为取模运算符，$mod会将查询的值除以第一个给定的值，若余数等于第二个给定值则会返回该结果 db.users.find({ 'id_num' : {$mod : [5, 1]}}) //上面会返回id_num为1,6,11,16.... //但是想要放回2，3，4，5，7，8...就要使用$not了 db.users.find({ 'id_num' : {$not : {$mod : [5, 1]}}})

特定类型查询

正则表达式

?

1 2	//例如查询Joe或joe或者JOe db.users.find({ 'username' : /joe/i})

查询数组中的元素

?

1 2 3 4

//首先建立food表，并插入一个文档 db.food.insert({ 'fruit' :[ 'apple' , 'banana' , 'peach' ]}) //下面的查询会返回该文档 db.food.find({ 'fruit' : 'banana' })

• $all
  如果需要多个元素来匹配数组，就需要使用$all了
  

  ?

  1 2 3 4 5 6 7 8 9 10 11

  //假设在我们表中3个下面的文档 db.food.insert({ '_id' : 1, 'fruit' : [ 'apple' , 'banana' , 'peach' ]}) db.food.insert({ '_id' : 2, 'fruit' : [ 'apple' , 'kumquat' , 'orange' ]}) db.food.insert({ '_id' : 3, 'fruit' : [ 'cherry' , 'banana' , 'apple' ]})   //要找到既有apple又有banana的文档，就要用到$all了 db.food.find({ 'fruit' : {$all : [ 'apple' , 'banana' ]}})   //如果需要查询指定位置的元素，就需要使用key.index语法指定下标了 db.food.find({ 'fruit.2' : 'peach' }) //数组下标都是从0开始的，所以它会匹配到_id为1的文档

  
  

  
  

  
  

• $size
  对于查询数组来说意义非凡，可以用其来查询指定长度的数组。
  

  ?

  1 2 3 4 5 6 7 8 9 10 11 12 13

  //指定需要查询数组的长度 db.food.find({ 'fruit' : {$size : 3}})   //如果需要一个长度范围，需要一些技巧 //因为$siez查询不支持$gt，$gte等条件语句 //但是我们可以给每个文档增加一个size键，这样就可以方便我们查询了 db.food.insert({ '_id' : 1, 'fruit' : [ 'apple' , 'banana' , 'peach' ], 'size' : 3})   //当我们需要添加水果时 db.food.update({ '_id' : 1},{$push : { 'fruit' : 'strawberry' ,$inc:{ 'size' : 1}}})   //之后我们就可以使用下面这样子的查询了 db.food.find({ 'size' : {$gt : 3}})

  
  

  
  

  
  

• $slice操作符
  $slice返回数组的一个子集合
  

  ?

  1 2 3 4 5 6 7 8 9

  //返回一个博客文档的前10条评论 db.posts.findOne({ '_id' : 1}, { 'comments' : {$slice : 10}})   //返回一个博客文档的后10条评论 db.posts.findOne({ '_id' : 1}, { 'comments' : {$slice : -10}})   //也接受便宜值和要返回的数量 //返回一个博客文档的从第24条评论开始的10条评论 db.posts.findOne({ '_id' : 1}, { 'comments' : {$slice : [23, 10]}})

查询内嵌文档

可以查询整个文档或者针对键值进行查询

?

1 2 3 4 5 6 7 8 9 10 11

//假如有以下文档 {    'name' : {      'first' : 'Joe' ,      'last'  : 'Schmoe'    }    'age'  : 45 }   //要查询姓名是Joe Schmoe的人可以这样 db.users.find({ 'name.fisrt' : 'Joe' , 'name.last' : 'Schmoe' })

$where的使用

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

//假设我们的表food有两个文档如下 /* 0 */ {      "_id" : ObjectId( "52dd1effaad1ad6d22d62a33" ),      "apple" : 4,      "banana" : 4 }   /* 1 */ {      "_id" : ObjectId( "52dd2157aad1ad6d22d62a34" ),      "apple" : 5,      "banana" : 6 }   //我们要查询其中的apple和banana相等的文档 //函数中的this代表着将要返回的文档 db.food.find({      $where : function () {         if ( this .apple && this .banana && this .apple == this .banana)         {             return true          } else {             return false      }}})

这样子查询性能不高，一般不建议使用，但是如果确实是没有好的方法也可以使用，查询的结果非常直观!

原文来自：http://my.oschina.net/u/947360/blog/194532

文章二：

1.  基本查询：
    构造查询数据。
    > db.test.findOne()
    {
         "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"),
         "name" : "stephen",
         "age" : 35,
         "genda" : "male",
         "email" : "stephen@hotmail.com"
    }
 
    --多条件查询。下面的示例等同于SQL语句的where name = "stephen" and age = 35
    > db.test.find({"name":"stephen","age":35})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35, "genda" : "male", "email" : "stephen@hotmail.com" }
 
    --返回指定的文档键值对。下面的示例将只是返回name和age键值对。
    > db.test.find({}, {"name":1,"age":1})
   { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35 }

 

    --指定不返回的文档键值对。下面的示例将返回除name之外的所有键值对。
    > db.test.find({}, {"name":0})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "age" : 35, "genda" : "male", "email" : "stephen@hotmail.com" }
 
2.  查询条件：
    MongoDB提供了一组比较操作符：$lt/$lte/$gt/$gte/$ne，依次等价于</<=/>/>=/!=。
    --下面的示例返回符合条件age >= 18 && age <= 40的文档。
    > db.test.find({"age":{"$gte":18, "$lte":40}})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" }
 
    --下面的示例返回条件符合name != "stephen1"
    > db.test.find({"name":{"$ne":"stephen1"}})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" }
 
    --$in等同于SQL中的in，下面的示例等同于SQL中的in ("stephen","stephen1")
    > db.test.find({"name":{"$in":["stephen","stephen1"]}})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" }  
 
    --和SQL不同的是，MongoDB的in list中的数据可以是不同类型。这种情况可用于不同类型的别名场景。
    > db.test.find({"name":{"$in":["stephen",123]}})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" } 
 
    --$nin等同于SQL中的not in，同时也是$in的取反。如：
    > db.test.find({"name":{"$nin":["stephen2","stephen1"]}})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" }
 
    --$or等同于SQL中的or，$or所针对的条件被放到一个数组中，每个数组元素表示or的一个条件。
    --下面的示例等同于name = "stephen1" or age = 35
    > db.test.find({"$or": [{"name":"stephen1"}, {"age":35}]})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" } 
 
    --下面的示例演示了如何混合使用$or和$in。
    > db.test.find({"$or": [{"name":{"$in":["stephen","stephen1"]}}, {"age":36}]})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" } 
 
    --$not表示取反，等同于SQL中的not。
    > db.test.find({"name": {"$not": {"$in":["stephen2","stephen1"]}}})
    { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "stephen@hotmail.com" }

 

3.  null数据类型的查询：
    --在进行值为null数据的查询时，所有值为null，以及不包含指定键的文档均会被检索出来。
    > db.test.find({"x":null})
    { "_id" : ObjectId("4fd59d30b9ac507e96276f1b"), "x" : null }
    { "_id" : ObjectId("4fd59d49b9ac507e96276f1c"), "y" : 1 }
 
    --需要将null作为数组中的一个元素进行相等性判断，即便这个数组中只有一个元素。
    --再有就是通过$exists判断指定键是否存在。
    > db.test.find({"x": {"$in": [null], "$exists":true}})
    { "_id" : ObjectId("4fd59d30b9ac507e96276f1b"), "x" : null }
 
4.  正则查询：
    --MongoDB中使用了Perl规则的正则语法。如：
    > db.test.find()
    { "_id" : ObjectId("4fd59ed7b9ac507e96276f1d"), "name" : "stephen" }
    { "_id" : ObjectId("4fd59edbb9ac507e96276f1e"), "name" : "stephen1" }
    --i表示忽略大小写
    > db.test.find({"name":/stephen?/i})
    { "_id" : ObjectId("4fd59ed7b9ac507e96276f1d"), "name" : "stephen" }
    { "_id" : ObjectId("4fd59edbb9ac507e96276f1e"), "name" : "stephen1" } 
 
5.  数组数据查询：
    --基于数组的查找。
    > db.test.find()
    { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat","orange" ] }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana","apple" ] }
    --数组中所有包含banana的文档都会被检索出来。
    > db.test.find({"fruit":"banana"})
    { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana","apple" ] }
    --检索数组中需要包含多个元素的情况，这里使用$all。下面的示例中，数组中必须同时包含apple和banana，但是他们的顺序无关紧要。
    > db.test.find({"fruit": {"$all": ["banana","apple"]}})
    { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana", "apple" ] } 
    --下面的示例表示精确匹配，即被检索出来的文档，fruit值中的数组数据必须和查询条件完全匹配，即不能多，也不能少，顺序也必须保持一致。
    > db.test.find({"fruit":["apple","banana","peach"]})
    { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", peach" ] } 
    --下面的示例将匹配数组中指定下标元素的值。数组的起始下标是0。
    > db.test.find({"fruit.2":"peach"})
    { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", peach" ] } 
    --可以通过$size获取数组的长度，但是$size不能和比较操作符联合使用。
    > db.test.find({"fruit": {$size : 3}})
    { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat","orange" ] }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana","apple" ] } 
    --如果需要检索size > n的结果，不能直接使用$size，只能是添加一个额外的键表示数据中的元素数据，在操作数据中的元素时，需要同时更新size键的值。
    --为后面的实验构造数据。
    > db.test.update({}, {"$set": {"size":3}},false,true)
    > db.test.find()
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat", "orange" ], "size" : 3 }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana", "apple" ], "size" : 3 } 
    --每次添加一个新元素，都要原子性的自增size一次。
    > test.update({},{"$push": {"fruit":"strawberry"},"$inc":{"size":1}},false,true)
    > db.test.find()
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat", "orange", "strawberry" ], "size" : 4 }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana", "apple", "strawberry" ], "size" : 4 }
    --通过$slice返回数组中的部分数据。"$slice":2表示数组中的前两个元素。
    > db.test.find({},{"fruit": {"$slice":2}, "size":0})
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat" ]}
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana" ]} 
    --通过$slice返回数组中的部分数据。"$slice":-2表示数组中的后两个元素。
    > db.test.find({},{"fruit": {"$slice":-2}, "size":0})
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "orange", "strawberry" ] }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "apple", "strawberry" ] }
    --$slice : [2,1]，表示从第二个2元素开始取1个，如果获取数量大于2后面的元素数量，则取后面的全部数据。
    > db.test.find({},{"fruit": {"$slice":[2,1]}, "size":0})
    { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "orange" ] }
    { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "apple" ] }
 
6.  内嵌文档查询：
    --为后面的示例构造测试数据。
    > db.test.find()
    { "_id" : ObjectId("4fd5ada3b9ac507e96276f22"), "name" : { "first" : "Joe", "last" : "He" }, "age" : 45 }
    --当嵌入式文档为数组时，需要$elemMatch操作符来帮助定位某一个元素匹配的情况，否则嵌入式文件将进行全部的匹配。
    --即检索时需要将所有元素都列出来作为查询条件方可。
    > db.test.findOne()
    {
         "_id" : ObjectId("4fd5af76b9ac507e96276f23"),
         "comments" : [
                 {
                         "author" : "joe",
                         "score" : 3
                 },
                 {
                         "author" : "mary",
                         "score" : 6
                 }
         ]
    }
    > db.test.find({"comments": {"$elemMatch": {"author":"joe","score":{"$gte":3}}}}
    { "_id" : ObjectId("4fd5af76b9ac507e96276f23"), "comments" : [ { "author" : "joe", "score" : 3 }, { "author" : "mary", "score" : 6 } ] }
 
7.  游标：
    数据库使用游标来返回find()的执行结果，客户端对游标可以进行有效的控制，如：限定结果集的数量、跳过部分结果、基于任意键的任意方向的排序等。
    下面的例子将用于准备测试数据。
    > db.testtable.remove()
    > for (i = 0; i < 10; ++i) {
    ... db.testtable.insert({x:i})
    ... }
    我们可以通过cursor提供的hasNext()方法判断是否还有未读取的数据，再通过next()方法读取结果集中的下一个文档。如：
    > var c = db.testtable.find()
    > while (c.hasNext()) {
    ... print(c.next().x)
    ... }
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    当调用find()的时候，shell并不立即查询数据库，而是等待真正开始要求获得结果的时候才发送查询，这样在执行之前可以给查询附加额外的选项。几乎所有的游标方法都返回本身，因此可以像下面这样将游标的方法链式组合起来。如：
    > var c1 = db.testtable.find().sort({"x":1}).limit(1).skip(4);
    > var c2 = db.testtable.find().limit(1).sort({"x":1}).skip(4);
    > var c3 = db.testtable.find().skip(4).limit(1).sort({"x":1});
    此时，查询并未执行，所有这些函数都是在构造查询，当执行下面的语句时，查询将被真正执行，
    > c.hasNext()
    查询被发送到服务器，MongoDB服务器每次将返回一批数据，当本批被全部迭代后再从服务器读取下一批数据，直至查询结果需要的数据被全部迭代。
 
    对于上面的示例，limit(1)表示输出结果仅为一个，如果小于1，则不输出，即limit(n)函数限定的是最多输出结果。skip(4)表示跳过查询结果中的前4个文档，如果结果小于4，则不会返回任何文档。sort({"x":1})用于设定排序条件，即按照x键以升序(1)的方式排序，如果需要降序排序可以改为：sort({"x":-1})。sort也可以支持多键排序，如：sort({username:1, age:-1})即先按照username进行升序排序，如果username的值相同，再以age键进行降序排序。这里需要指出的是，如果skip过多的文档，将会导致性能问题。 

原文来自：http://www.cnblogs.com/stephen-liu74/archive/2012/08/03/2553803.html