本文详细介绍MongoDB中的查询方法find()及其参数使用，包括查询条件、返回字段控制等，并介绍了多种查询操作符的应用场景。
1.1 集合查询方法 find()
db.collection.find() 查询集合中文档并返回结果为游标的文档集合。
语法：db.collection.find(query, projection)
参数 类型 描述
query 文档 可选. 使用查询操作符指定查询条件
projection 文档 可选.使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）.
返回值: 匹配查询条件的文档集合的游标. 如果指定投影参数，查询出的文档返回指定的键 ,"_id"键也可以从集合中移除掉。
注意:在mongo shell中我们不需要JavaScript游标处理方法就可以直接访问作为查询结果的文档集合。mongo shell默认返回游标中的前20条文档。当执行查询操作时，mongo shell直接自动的对游标执行迭代操作并显示前20条文档。输入"it"显示接下来的20条文档。
find的第一个参数是查询条件，其形式也是一个文档，决定了要返回哪些文档，空的査询文档{}会匹配集合的全部内容。要是不指定査询文档，默认就是{}，如同SQL中"SELECT * FROM TABLENAME"语句。
//将返回集合中所有文档 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)，文档中若存在相同键的值和查询文档中键的值相等的话，就会返回该文档。
第一个参数若包含多个键/值对(逗号分隔)，则相当于查询AND组合条件，“条件1 AND条件2 AND…AND 条件N".例如查询年龄为28且性别为男性的文档集合：
//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"
指定返回的键
我们可以通过find 的第二个参数来指定返回的键。
若find不指定第二个参数，查询操作默认返回查询文档中所有键值。像SQL中我们可以指定查询返回字段一样 ，mongo中也可以指定返回的键，这样我们就可以避免查询无用键值查询所消耗的资源、会节省传输的数据量和内存消耗。
集合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"})
"$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"
语法: { 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 } } } );
查询结果：
-
_id为1的文档，students数组包含多个元素中存在school键且值为102的元素，$elemMatch只返回一个匹配条件的元素。
-
_id为3中的文档，因为students数组中元素无法匹配$elemMatch条件，所以查询结果不包含"students"字段。
$elemMatch可以指定多个字段的限定条件，下面的操作将查询邮政编码键值是63109的所有文档。 $elemMatch操作符将返回 students数组中的第一个匹配条件（内嵌文档的school键且值为102且age键值大于10）的元素。
db.school.find( { zipcode: 63109 },{ students: { $elemMatch: { school: 102, age: { $gt: 10} } } } );
_id等于3 和4的文档，因为students数组中没有元素匹配的$elemMatch条件，查询结果不包含“ students”字段。
实例记载：
1.count 统计数量。
在MongoDB中可以用count来同意一个集合中的文档数量。
- > use php //使用php这个库
- switched to db php
- > show collections //查看这个库下面有多少个集合
- blog
- foo
- system.indexes
- user
- > db.blog.count() //使用count查看blog集合中的文档数量。3个。
- 3
- >
- > db.blog.count({"title":"wowowo"}) //统计title为"wowowo"的文档的个数。为0个
- 0
- > db.blog.count({"title":"wowowowo"})//统计title为"wowowowo"的文档的个数，为2个。
- 2
- >
2.distinct
在MongdoDB中 distinct 用来找出给定键的所有不同的值，即是去重复，使用时，必须制定集合和键。
使用distinct 必须使用runCommand( )结合的方式。db.runCommand( )以前没说过。
- > db.runCommand()
- { "errmsg" : "no such cmd: ", "bad cmd" : { }, "ok" : 0 }
- > db.runCommand({"distinct":"blog","key":"title"}) //必须制定集合和键。制定blog集合，title键。
- {
- "values" : [
- "wowowowo",
- "okokok"
- ],
- "stats" : {
- "n" : 3,
- "nscanned" : 3,
- "nscannedObjects" : 3,
- "timems" : 15,
- "cursor" : "BasicCursor"
- },
- "ok" : 1
- }
- > db.runCommand({"distinct":"blog","key":"comments"}) //制定blog集合，comments键
- {
- "values" : [
- "hao a hao a ",
- "23224"
- ],
- "stats" : {
- "n" : 3,
- "nscanned" : 3,
- "nscannedObjects" : 3,
- "timems" : 0,
- "cursor" : "BasicCursor"
- },
- "ok" : 1
- }
- > db.runCommand({"distinct":"blog","key":"time"}) //key键。
- {
- "values" : [
- ISODate("2012-01-10T03:38:45.515Z"),
- "2011023023"
- ],
- "stats" : {
- "n" : 3,
- "nscanned" : 3,
- "nscannedObjects" : 3,
- "timems" : 0,
- "cursor" : "BasicCursor"
- },
- "ok" : 1
- }
- >
3.group
MongoDB中的group和mysql中的group分组差不多。
group做的聚合稍微复杂一些，先选定分组所依据的键，而后MongoDB就会将集合依据选定键值的不同分成若干组。然后可以通过聚合每一组内的文档，产生一个结果文档。
比如有以下数据：表示股价的结合包含以千计的如下形式的文档。
- {"day":"2010/10/03","time":"10/3/2010 03:57:01 GMT-400","price":4.23}
- {"day":"2010/10/04","time":"10/4/2010 11:28:34 GMT-400","price":4.27}
- {"day":"2010/10/03","time":"10/3/2010 05:00:51 GMT-400","price":4.10}
- {"day":"2010/10/06","time":"10/6/2010 05:27:22 GMT-400","price":4.30}
- {"day":"2010/10/04","time":"10/4/2010 08:24:58 GMT-400","price":4.01}
- {"day":"2010/10/03","time":"10/3/2010 05:00:51 GMT-400","price":4.10}
- {"day":"2010/10/04","time":"10/4/2010 11:28:34 GMT-400","price":4.27}
- {"day":"2010/10/06","time":"10/6/2010 05:27:22 GMT-400","price":4.30}
那么我们用group如何做到像这样的分组呢？
- > db.runCommand({"group":{
- ... "ns":"stocks",
- ... "key":"day",
- ... "initial":{"time":0},
- ... "$reduce":function(doc,prev){
- ... if(doc.time>prev.time){
- ... prev.price=doc.price;
- ... prev.time=doc.time;
- ... }
- ... }}})
- {
- "retval" : [
- {
- "time" : 0
- }
- ],
- "count" : 5,
- "keys" : 1,
- "ok" : 1
- }
- >
Mongodb一些常用的查询
WHERE查询
|
1
2
|
// i.e., select * from things where x=3 and y="foo"
db.things.find( { x : 3, y :
"foo"
} );
|
j不等于3，k大于10
|
1
|
db.things.find({j: {$ne: 3}, k: {$gt: 10} });
|
存储数组元素
|
1
2
3
4
5
|
db.things.insert({colors : [
"blue"
,
"black"
]})
db.things.insert({colors : [
"yellow"
,
"orange"
,
"red"
]})
//查询结果
db.things.find({colors : {$ne :
"red"
}})
{
"_id"
: ObjectId(
"4dc9acea045bbf04348f9691"
),
"colors"
: [
"blue"
,
"black"
]}
|
对比操作符
|
1
2
3
4
|
db.collection.find({
"field"
: { $gt: value } } );
// greater than : field > value
db.collection.find({
"field"
: { $lt: value } } );
// less than : field < value
db.collection.find({
"field"
: { $gte: value } } );
// greater than or equal to : field >= value
db.collection.find({
"field"
: { $lte: value } } );
// less than or equal to : field <=
|
$all 全部属于
|
1
|
db.things.find( { a: { $all: [ 2, 3 ] } } )
|
$exists 字段存在
|
1
2
3
|
db.things.find( { a : { $exists :
true
} } )
db.things.find( { a : { $exists :
false
} } )
true
返回存在字段a的数据，
false
返回不存在字度a的数据。
|
$mod 取模运算
|
1
2
|
db.things.find( { a : { $mod : [ 10 , 1 ] } } )
条件相当于a % 10 == 1 即a除以10余数为1的。
|
$ne 不等于
|
1
2
|
db.things.find( { x : { $ne : 3 } } )
条件相当于x<>3,即x不等于3。
|
$in 属于
|
1
2
|
db.things.find({j:{$
in
: [2,4,6]}})
条件相当于j等于[2,4,6]中的任何一个。
|
$nin 不属于
|
1
2
|
db.things.find({j:{$nin: [2,4,6]}})
条件相当于 j 不等于 [2,4,6] 中的任何一个。
|
$or 或 （注意：MongoDB 1.5.3后版本可用）
|
1
2
|
db.foo.find( { $or : [ { a : 1 } , { b : 2 } ] } )
符合条件a=1的或者符合条件b=2的数据都会查询出来。
|
$size 数量，尺寸
|
1
2
|
db.things.find( { a : { $size: 1 } } )
条件相当于a的值的数量是1（a必须是数组，一个值的情况不能算是数量为1的数组）。
|
$type 字段类型
|
1
2
|
db.things.find( { a : { $type : 2 } } )
条件是a类型符合的话返回数据。
|
limit() skip()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
这两个ME想连起来讲，他们就是你实现数据库分页的好帮手。
limit()控制返回结果数量，如果参数是0，则当作没有约束，limit()将不起作用。
skip()控制返回结果跳过多少数量，如果参数是0，则当作没有约束，skip()将不起作用，或者说跳过了0条。
例如：
db.test.find().skip(5).limit(5)
结果就是取第6条到第10条数据。
snapshot() （没有尝试）
count() 条数
返回结果集的条数。
db.test.count()
在加入skip()和limit()这两个操作时，要获得实际返回的结果数，需要一个参数
true
，否则返回的是符合查询条件的结果总数。
例子如下：
> db.test.find().skip(5).limit(5).count()
9
> db.test.find().skip(5).limit(5).count(
true
)
4
|
11) $elemMatch
|
1
2
3
4
5
6
7
8
9
|
如果对象有一个元素是数组，那么$elemMatch可以匹配内数组内的元素：
t.find( { x : { $elemMatch : { a : 1, b : { $gt : 1 } } } } )
{
"_id"
: ObjectId(
"4b5783300334000000000aa9"
),
"x"
: [ {
"a"
: 1,
"b"
: 3 }, 7, {
"b"
: 99 }, {
"a"
: 11 } ]
}
$elemMatch : { a : 1, b : { $gt : 1 } } 所有的条件都要匹配上才行。
注意，上面的语句和下面是不一样的。
t.find( {
"x.a"
: 1,
"x.b"
: { $gt : 1 } } )
$elemMatch是匹配{
"a"
: 1,
"b"
: 3 }，而后面一句是匹配{
"b"
: 99 }, {
"a"
: 11 }
|
12) 查询嵌入对象的值
|
1
2
3
4
5
6
7
8
9
10
11
|
db.postings.find( {
"author.name"
:
"joe"
} );
注意用法是author.name，用一个点就行了。更详细的可以看这个链接： dot notation
举个例子：
db.blog.save({ title :
"My First Post"
, author: {name :
"Jane"
, id : 1}})
如果我们要查询 authors name 是Jane的, 我们可以这样：
db.blog.findOne({
"author.name"
:
"Jane"
})
如果不用点，那就需要用下面这句才能匹配：
db.blog.findOne({
"author"
: {
"name"
:
"Jane"
,
"id"
: 1}})
下面这句：
db.blog.findOne({
"author"
: {
"name"
:
"Jane"
}})
是不能匹配的，因为mongodb对于子对象，他是精确匹配。
|
扫一扫
2782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
