MongoDB学习 (六)：查询

时间 2019-11-12

原文原文链接

　本文地址:http://www.cnblogs.com/egger/archive/2013/06/14/3135847.html 欢迎转载，请保留此连接๑•́ ₃•̀๑！　　javascript

　本文将介绍操做符的使用，配合操做符，咱们能够执行更加复杂的操做。html

参数 　　　　　类型 　　　　描述 
query	　　　 文档	　 可选. 使用查询操做符指定查询条件
projection  　 文档	　 可选.使用投影操做符指定返回的键。查询时返回文档中全部键值， 只需省略该参数便可（默认省略）.

返回值: 匹配查询条件的文档集合的游标. 若是指定投影参数，查询出的文档返回指定的键 ,"_id"键也能够从集合中移除掉。

注意:在mongo shell中咱们不须要JavaScript游标处理方法就能够直接访问做为查询结果的文档集合。mongo shell默认返回游标中的前20条文档。当执行查询操做时，mongo shell直接自动的对游标执行迭代操做并显示前20条文档。输入"it"显示接下来的20条文档。

　　find的第一个参数是查询条件，其形式也是一个文档，决定了要返回哪些文档，空的査询文档{}会匹配集合的所有内容。要是不指定査询文档，默认就是{}，如同SQL中"SELECT * FROM TABLENAME"语句。ajax

//将返回集合中全部文档
db.collection.find()
//或者
db.collection.find({})

　　第一个参数若为键/值对时，查询过程当中就意味着执行了条件筛选，就如同咱们使用Linq查询数据库同样。下面查询操做将返回user集合中age键值为16的文档集合。正则表达式

//mongo db
db.user.find({age:16})

//Linq to sql
dbContext.user.select(p=>p.age==16)

　　上面的查询默认执行“==”操做(就如同linq中 p.age==16)，文档中若存在相同键的值和查询文档中键的值相等的话，就会返回该文档。sql

　　第一个参数若包含多个键/值对(逗号分隔)，则至关于查询AND组合条件，“条件1 AND条件2 AND…AND 条件N".例如查询年龄为28且性别为男性的文档集合：mongodb

//mongo db
db.user.find({age:28,sex:"male"})

//Linq to sql
dbContext.user.select(p=>p.age==28&&p.sex=="male")

//SQL
SELECT * FROM user WHERE age=28 AND sex="male"

指定返回的键shell

　　咱们能够经过find 的第二个参数来指定返回的键。数据库

　　若find不指定第二个参数，查询操做默认返回查询文档中全部键值。像SQL中咱们能够指定查询返回字段同样，mongo中也能够指定返回的键，这样咱们就能够避免查询无用键值查询所消耗的资源、会节省传输的数据量和内存消耗。express

　集合user包含 _id,name,age,sex，email等键,若是查询结果想只显示集合中的"name"和"age"键，可使用以下查询返回这些键,。

> db.users.find({}, {"name" ： 1, "age" ： 1})

　　上面查询结果中，"_id"这个键老是被返回，即使是没有指定也同样。可是咱们能够显示的将其从查询结果中移除掉。

> db.users.find({}, {"name" ： 1, "age" ： 1, "_id"：0})

　　在第二个参数中，指定键名且值为1或者true则是查询结果中显示的键；若值为0或者false，则为不显示键。文档中的键若在参数中没有指定，查询结果中将不会显示（_id例外）。这样咱们就能够灵活显示声明来指定返回的键。

　　咱们在使用RDMS时，有时会对表中多个字段之间进行比较。如表store中，有销售数量soldnum和库存数量stocknum两个字段，咱们要查询表中销售数量等于库存数量的记录时可使用下面的sql语句：

SELECT * FROM store WHERE soldnum=stocknum

　　那么换成mongodb呢，使用find()能实现相似的功能吗？

> db.store.find ({ "soldnum" : "stocknum"})
//或者
> db.store.find ({ "stocknum":"soldnum" })

　　结果是不行的！！咱们可使用$where运算符来进行相应的操做。

1.2 查询内嵌文档

　　查询文档有两种方式，一种是彻底匹查询，另外一种是针对键/值对查询。

> db.profile.find()
{ "_id" : ObjectId("51d7b0d436332e1a5f7299d6"), "name" : { "first" : Barack", "last" : "Obama" } }
>

　　内嵌文档的彻底匹配查询和数组的彻底匹配查询同样，内嵌文档内键值对的数量，顺序都必须一致才会匹配:

> db.profile.find({ name : { first : "Barack", last : "Obama" } });
{ "_id" : ObjectId("51d7b0d436332e1a5f7299d6"), "name" : { "first" : Barack", "last" : "Obama" } }
>

//无任何返回值
> db.profile.find({ name : {  last : "Obama" , first : "Barack"} });
>

　　推荐采用针对键/值对查询，经过点表示法来精确表示内嵌文档的键：

//查询结果同样
db.profile.find({  "name.first" : "Barack" , "name.last" : "Obama"});
//或者
db.profile.find({  "name.last" : "Obama" , "name.first" : "Barack"} );

　　运行结果：

査询文档能够包含点，来表达“深刻内嵌文档内部”的意思，点表示法也是待插入的文档不能包含的缘由。当内嵌文档变得复杂后，如键的值为内嵌文档的数组，内嵌文档的匹配须要些许技巧，例如使用$elemMatch操做符。

集合blogs有以下文档：

{
        "content" : ".....",
        "comment" : [
                {
                        "author" : "zhangsan",
                        "score" : 3,
                        "comment" : "shafa!"
                },
                {
                        "author" : "lisi",
                        "score" : 5,
                        "comment" : "lzsb!"
                }
        ]
}

咱们想查询评论中用户“zhangsan”是否有评分超过4分的评论内容，但咱们利用“点表示法”直接写是有问题的，这条查询条件和数组中不一样的文档进行了匹配！

> db.blogs.find({"comment.author":"zhangsan", "comment.score":{"$gte":4}});

上面的结果不是咱们指望的，下面使用“$elemMatch”操做符便可将一组条件限定到数组中单条文档的匹配上：

> db.blogs.find({"comment":{"$elemMatch":{"author":"zhangsan","score":{"$gt":4}}}});
> db.blogs.find({"comment":{"$elemMatch":{"author":"zhangsan","score":{"$gt":2}}}});

1.3 查询操做符　　

　　下面咱们将配合查询操做符来执行复杂的查询操做，好比元素查询、逻辑查询、比较查询操做。　

　　咱们使用下面的比较操做符"$gt" 、"$gte"、 "$lt"、 "$lte"(分别对应">"、 ">=" 、"<" 、"<=")，组合起来进行范围的查找。例如查询年龄为16-18岁(包含16但不含18)的用户：

>db.user.find( { age: { $gte: 16 ,$lt:18} }

　　咱们可使用"$ne"来进行"不相等"操做。例如查询年龄不为18岁的用户：

>db.user.find( { age: {$ne:18} }

　　精确匹配日期要精确到毫秒,然而咱们一般只是想获得关于一天、一周或者是一个月的数据，咱们可使用"$gt" 、 "$lt"进行范围査询。例如，要査找在1990年1月1日出生的用户：

>    start = new Date("1990/01/01")
>    db.users.find({"birthday" ： {"$lt" ： start}})

键值为null查询操做

　　如何检索出sex键值为null的文档，咱们使用"$in" 、"$where"操做符，"$in"判断键值是否为null,"$exists"断定集合中文档是否包含该键。

//集合中有一条sex键值为null的文档
{"name":"xiaoming","age":20,"sex":"male"}
{"name":"xiaohong","age":22,"sex":"female"}
{"name":"lilei","age":24,"sex":null}

//返回文档中存在sex键，且值为null的文档  
db.users.find({sex:{$in:[null],$exists:true }})

//返回文档中存在birthday键，且值为null的文档 
//文档没有birthday键，因此结果为空
db.users.find({birthday:{$in:[null],$exists:true }})

　　运行截图：

　　咱们也能够运行以下语句：

> db.users.find({sex:null})

　　查询结果跟语句"db.users.find({sex:{$in:[null],$exists:true }})"同样

　　可是当为咱们运行下面语句时，发现查询结果跟语句"db.users.find({birthday:{$in:[null],$exists:true }})"不同！

> db.users.find({birthday:null})

　　查询返回了全部的文档！

　　由于null不只仅匹配自身，并且匹配键“不存在的”文档，集合众文档都不存在"birthday"键,都匹配查询条件，因此上面的语句会返回全部的文档！

　　咱们最好使用db.users.find({sex:{$in:[null],$exists:true }})这种格式。

　　下面先向集合inventory插入3条数据（下面的演示基于此数据），文档内容以下：

　　{"name":"t1","amount":16,"tags":[ "school", "book", "bag", "headphone", "appliances" ]}
　　{"name":"t2","amount":50,"tags":[ "appliances", "school", "book" ]}
　　{"name":"t3","amount":58,"tags":[ "bag", "school", "book" ]}

"$all"

　　匹配那些指定键的键值中包含数组，并且该数组包含条件指定数组的全部元素的文档,数组中元素顺序不影响查询结果。

语法: { field: { $all: [ <value> , <value1> ... ] }

　　查询出在集合inventory中 tags键值包含数组，且该数组中包含appliances、school、 book元素的全部文档:

db.inventory.find( { tags: { $all: [ "appliances", "school", "book" ] } } )

　　该查询将匹配tags键值包含以下任意数组的全部文档:

[ "school", "book", "bag", "headphone", "appliances" ]
[ "appliances", "school", "book" ]

　　查询结果：

　　文档中键值类型不是数组，也可使用$all操做符进行查询操做，以下例所示"$all"对应的数组只有一个值，那么和直接匹配这个值效果是同样的。

//查询结果是相同的，匹配amount键值等于50的文档
db.inventory.find( { amount: {$all:[50]}} )
db.inventory.find( { amount: 50}} )

　　要是想查询数组指定位置的元素，则需使用key.index语法指定下标，例以下面查询出tags键值数组中第2个元素为"school"的文档：

> db.inventory.find({"tags.1":"school"})

　　数组下标都是从0开始的，因此查询结果返回数组中第2个元素为"school"的文档：

"$size"

　　用其查询指定长度的数组。

语法：{field: {$size: value} }

　　查询集合中tags键值包含有3个元素的数组的全部文档：

> db.inventory.find({tags:{$size:3}})

　　文档"{"name":"t1","amount":16,"tags":[ "school", "book", "bag", "headphone", "appliances" ]}",tags键值数组包含四个元素，因此不匹配查询条件。查询结果：

　　$size必须制定一个定值，不能接受一个范围值，不能与其余查询子句组合(好比"$gt")。但有时查询需求就是须要一个长度范围，这种状况建立一个计数器字段，当你增长元素的同时增长计数器字段值。

//每一次向指定数组添加元素的时候,"count"键值增长1(充当计数功能)
db.collection.update({ $push : {field: value}, $inc ：{count ： 1}})
//比较count键值实现范围查询
db.collection.find({count : {$gt:2}})

"$in"

　　匹配键值等于指定数组中任意值的文档。相似sql中in.

语法: { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

"$nin"

　　匹配键不存在或者键值不等于指定数组的任意值的文档。相似sql中not in(SQL中字段不存在使用会有语法错误).

语法: { field: { $nin: [ <value1>, <value2> ... <valueN> ]} }

　查询出amount键值为16或者50的文档：

db.inventory.find( { amount: { $in: [ 16, 50 ] } } )

//查询出amount键值不为16或者50的文档
db.inventory.find( { amount: { $nin: [ 16, 50 ] } } )
//查询出qty键值不为16或50的文档，因为文档中都不存在键qty,因此返回全部文档
db.inventory.find( { qty: { $nin: [ 16, 50 ] } } )

　　文档中键值类型不是数组，也可使用$all操做符进行查询操做，以下例所示"$in"对应的数组只有一个值，那么和直接匹配这个值效果是同样的。

//查询结果是相同的，匹配amount键值等于50的文档
db.inventory.find( { amount: {$in:[50]}} )
db.inventory.find( { amount: 50}} )

"$and"

　　指定一个至少包含两个表达式的数组，选择出知足该数组中全部表达式的文档。$and操做符使用短路操做，若第一个表达式的值为“false”,余下的表达式将不会执行。

语法: { $and: [ { <expression1> }, { <expression2> } , ... , { <expressionN> } ] }

　　查询name键值为“t1”,amount键值小于50的文档：

db.inventory.find({ $and: [ { name: "t1" }, { amount: { $lt：50 } } ] } )

　　对于下面使用逗号分隔符的表达式列表，MongoDB会提供一个隐式的$and操做：

//等同于{ $and: [ { name: "t1" }, { amount: { $lt：50 } } ] }
 db.inventory.find({ name: "t1" , amount: { $lt：50 }} )

"$nor"

　　执行逻辑NOR运算,指定一个至少包含两个表达式的数组，选择出都不知足该数组中全部表达式的文档。

语法: { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

　　查询name键值不为“t1”,amount键值不小于50的文档：

db.inventory.find( { $nor: [ { name: "t1" }, { qty: { $lt: 50 } } ] } )

　　如果文档中不存在表达式中指定的键，表达式值为false; false nor false 等于 true,因此查询结果返回集合中全部文档：

db.inventory.find( { $nor: [ { sale: true }, { qty: { $lt: 50 } } ] } )

"$not"

　　执行逻辑NOT运算，选择出不能匹配表达式的文档，包括没有指定键的文档。$not操做符不能独立使用，必须跟其余操做一块儿使用（除$regex）。

语法: { field: { $not: { <operator-expression> } } }

　　查询amount键值不大于50（即小于等于50）的文档数据

db.inventory.find( { amount: { $not: { $gt: 50 } } } ) //等同于db.inventory.find( { amount:  { $lte: 50 } } )

　　查询条件中的键gty，文档中都不存在没法匹配表示，因此返回集合全部文档数据。

db.inventory.find( { gty: { $not: { $gt: 50 } } } ）

"$or"

　　执行逻辑OR运算,指定一个至少包含两个表达式的数组，选择出至少知足数组中一条表达式的文档。

语法: { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }

　　查询集合中amount的键值大于50或者name的键值为“t1”的文档：

db.inventory.find( { $or: [ { amount: { $gt: 50 } }, { name: "t1" } ] } )

"$exists"

　　若是$exists的值为true,选择存在该字段的文档；若值为false则选择不包含该字段的文档(咱们上面在查询键值为null的文档时使用"$exists"断定集合中文档是否包含该键)。

语法: { field: { $exists: <boolean> } }

//查询不存在qty字段的文档（全部文档）
db.inventory.find( { qty: { $exists: false } })
//查询amount字段存在，且值不等于16和58的文档
db.inventory.find( { amount: { $exists: true, $nin: [ 16, 58 ] } } )

　　若是该字段的值为null，$exists的值为true会返回该条文档，false则不返回。

//向集合中插入一条amount键值为null的文档
{"name":"t4","amount":null,"tags":[ "bag", "school", "book" ]}

//0条数据
db.inventory.find( { amount: { $exists: false } } )
//全部的数据
db.inventory.find( { amount: { $exists: true } } )

"$mod"

　　匹配字段值对（divisor）取模，值等于（remainder）的文档。

语法: { field: { $mod: [ divisor, remainder ]} }

　　查询集合中 amount 键值为 4 的 0 次模数的全部文档，例如 amount 值等于 16 的文档

db.inventory.find( { amount: { $mod: [ 4, 0 ] } } )

　　有些状况下(特殊状况键值为null时)，咱们可使用$mod操做符替代使用求模表达式的$where操做符，由于后者代价昂贵。

db.inventory.find( { $where: "this.amount % 4 == 0" } )

　　注意：返回结果怎么不同。由于有一条文档的amount键值为null,javascript中null进行数值转换，会返回"0"。因此该条文档匹配$where操做符求模式了表达式。当文档中字段值不存在null，就可使用$mod替代$where的表达式.

"$regex"

　　操做符查询中能够对字符串的执行正则匹配。 MongoDB使用Perl兼容的正则表达式（PCRE)库来匹配正则表达式.

　　咱们可使用正则表达式对象或者$regex操做符来执行正则匹配：

//查询name键值以“4”结尾的文档
db.inventory.find( { name: /.4/i } );
db.inventory.find( { name: { $regex: '.4', $options: 'i' } } );

　　$options （使用$regex ）

i 　若是设置了这个修饰符，模式中的字母会进行大小写不敏感匹配。
m 默认状况下，PCRE 认为目标字符串是由单行字符组成的(然而实际上它可能会包含多行).若是目标字符串中没有 "\n"字符，或者模式中没有出现“行首”/“行末”字符，设置这个修饰符不产生任何影响。
s 若是设置了这个修饰符，模式中的点号元字符匹配全部字符，包含换行符。若是没有这个修饰符，点号不匹配换行符。
x 若是设置了这个修饰符，模式中的没有通过转义的或不在字符类中的空白数据字符总会被忽略，而且位于一个未转义的字符类外部的#字符和下一个换行符之间的字符也被忽略。这个修饰符使被编译模式中能够包含注释。注意：这仅用于数据字符。空白字符仍是不能在模式的特殊字符序列中出现，好比序列。

　　注：JavaScript只提供了i和m选项，x和s选项必须使用$regex操做符。

"$where"

　　操做符功能强大并且灵活，他可使用任意的JavaScript做为查询的一部分,包含JavaScript表达式的字符串或者JavaScript函数。

　　新建fruit集合并插入以下文档：

//插入两条数据
db.fruit.insert({"apple":1, "banana": 4, "peach" : 4})
db.fruit.insert({"apple":3, "banana": 3, "peach" : 4})

　　比较文档中的两个键的值是否相等.例如查找出banana等于peach键值的文档（4种方法）：

//JavaScrip字符串形式
db.fruit.find( { $where: "this.banana == this.peach" } )
db.fruit.find( { $where: "obj.banana == obj.peach" } )

//JavaScript函数形式
db.fruit.find( { $where: function() { return (this.banana == this.peach) } } )
db.fruit.find( { $where: function() { return obj.banana == obj.peach; } } )

　　查出文档中存在的两个键的值相同的文档，JavaScript函数会遍历集合中的文档：

>db.fruit.find({$where:function () {
        for (var current in this) {
            for (var other in this) {
                if (current != other && this[current] == this[other]) {
                return true;
                }
            }
        }
        return false;
    }});

　　注意：咱们尽可能避免使用"$Where"査询，由于它们在速度上要比常规査询慢不少。每一个文档都要从BSON转换成JavaScript对象，而后经过"$where"的表达式来运行;一样还不能利用索引。

"$slice (projection)"

　　$slice操做符控制查询返回的数组中元素的个数。

语法：db.collection.find( { field: value }, { array: {$slice: count } } );

　　此操做符根据参数"{ field: value }" 指定键名和键值选择出文档集合，而且该文档集合中指定"array"键将返回从指定数量的元素。若是count的值大于数组中元素的数量，该查询返回数组中的全部元素的。

　　$slice接受多种格式的参数包含负数和数组:

//选择comments的数组键值中前五个元素。
db.posts.find( {}, { comments: { $slice: 5 } } );

//选择comments的数组键值中后五个元素。
db.posts.find( {}, { comments: { $slice: -5 } } );

　　下面介绍指定一个数组做为参数。数组参数使用[ skip , limit ] 格式，其中第一个值表示在数组中跳过的项目数,第二个值表示返回的项目数。

//选择comments的数组键值中跳过前20项以后前10项元素
db.posts.find( {}, { comments: { $slice: [ 20, 10 ] } } );

//选择comments的数组键值中倒数第20项起前10项元素
db.posts.find( {}, { comments: { $slice: [ -20, 10 ] } } );

"$elemMatch(projection)"

$elemMatch投影操做符将限制查询返回的数组字段的内容只包含匹配$elemMatch条件的数组元素。

注意：

数组中元素是内嵌文档。
若是多个元素匹配$elemMatch条件，操做符返回数组中第一个匹配条件的元素。

假设集合school有以下数据：

{
 _id: 1,
 zipcode: 63109,
 students: [
              { name: "john", school: 102, age: 10 },
              { name: "jess", school: 102, age: 11 },
              { name: "jeff", school: 108, age: 15 }
           ]
}
{
 _id: 2,
 zipcode: 63110,
 students: [
              { name: "ajax", school: 100, age: 7 },
              { name: "achilles", school: 100, age: 8 },
           ]
}

{
 _id: 3,
 zipcode: 63109,
 students: [
              { name: "ajax", school: 100, age: 7 },
              { name: "achilles", school: 100, age: 8 },
           ]
}

{
 _id: 4,
 zipcode: 63109,
 students: [
              { name: "barney", school: 102, age: 7 },
           ]
}

下面的操做将查询邮政编码键值是63109的全部文档。 $elemMatch操做符将返回 students数组中的第一个匹配条件（内嵌文档的school键且值为102）的元素。

db.school.find( { zipcode: 63109 },{ students: { $elemMatch: { school: 102 } } } );