-
查询操作
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、查询所有记录
db.userInfo.find();
相当于：select* from userInfo;
默认每页显示20条记录，当显示不下的情况下，可以用it迭代命令查询下一页数据。注意：键入it命令不能带“；”
但是你可以设置每页显示数据的大小，用DBQuery.shellBatchSize= 50;这样每页就显示50条记录了。
2、查询去掉后的当前聚集集合中的某列的重复数据
db.userInfo.distinct("name");
会过滤掉name中的相同数据
相当于：select distict name from userInfo;
3、查询age = 22的记录
db.userInfo.find({"age": 22});
相当于： select * from userInfo where age = 22;
4、查询age > 22的记录
db.userInfo.find({age: {$gt: 22}});
相当于：select * from userInfo where age >22;
5、查询age < 22的记录
db.userInfo.find({age: {$lt: 22}});
相当于：select * from userInfo where age <22;
6、查询age >= 25的记录
db.userInfo.find({age: {$gte: 25}});
相当于：select * from userInfo where age >= 25;
7、查询age <= 25的记录
db.userInfo.find({age: {$lte: 25}});
8、查询age >= 23 并且 age <= 26
db.userInfo.find({age: {$gte: 23, $lte: 26}});
9、查询name中包含 mongo的数据
db.userInfo.find({name: /mongo/});
//相当于%%
select * from userInfo where name like ‘%mongo%’;
10、查询name中以mongo开头的
db.userInfo.find({name: /^mongo/});
select * from userInfo where name like ‘mongo%’;
11、查询指定列name、age数据
db.userInfo.find({}, {name: 1, age: 1});
相当于：select name, age from userInfo;
当然name也可以用true或false,当用ture的情况下河name:1效果一样，如果用false就是排除name，显示name以外的列信息。
12、查询指定列name、age数据, age > 25
db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1});
相当于：select name, age from userInfo where age >25;
13、按照年龄排序
升序：db.userInfo.find().sort({age: 1});
降序：db.userInfo.find().sort({age: -1});
14、查询name = zhangsan, age = 22的数据
db.userInfo.find({name: 'zhangsan', age: 22});
相当于：select * from userInfo where name = ‘zhangsan’ and age = ‘22’;
15、查询前5条数据
db.userInfo.find().limit(5);
相当于：selecttop 5 * from userInfo;
16、查询10条以后的数据
db.userInfo.find().skip(10);
相当于：select * from userInfo where id not in (
selecttop 10 * from userInfo
);
17、查询在5-10之间的数据
db.userInfo.find().limit(10).skip(5);
可用于分页，limit是pageSize，skip是第几页*pageSize
18、or与 查询
db.userInfo.find({$or: [{age: 22}, {age: 25}]});
相当于：select * from userInfo where age = 22 or age = 25;
19、查询第一条数据
db.userInfo.findOne();
相当于：selecttop 1 * from userInfo;
db.userInfo.find().limit(1);
20、查询某个结果集的记录条数
db.userInfo.find({age: {$gte: 25}}).count();
相当于：select count(*) from userInfo where age >= 20;
21、按照某列进行排序
db.userInfo.find({sex: {$exists: true}}).count();
相当于：select count(sex) from userInfo;
1、创建索引
db.userInfo.ensureIndex({name: 1});
db.userInfo.ensureIndex({name: 1, ts: -1});
2、查询当前聚集集合所有索引
db.userInfo.getIndexes();
3、查看总索引记录大小
db.userInfo.totalIndexSize();
4、读取当前集合的所有index信息
db.users.reIndex();
5、删除指定索引
db.users.dropIndex("name_1");
6、删除所有索引索引
db.users.dropIndexes();
修改、添加、删除集合数据
1、添加
db.users.save({name: ‘zhangsan’, age: 25, sex: true});
添加的数据的数据列，没有固定，根据添加的数据为准
2、修改
db.users.update({age: 25}, {$set: {name: 'changeName'}}, false, true);
相当于：update users set name = ‘changeName’ where age = 25;
db.users.update({name: 'Lisi'}, {$inc: {age: 50}}, false, true);
相当于：update users set age = age + 50 where name = ‘Lisi’;
db.users.update({name: 'Lisi'}, {$inc: {age: 50}, $set: {name: 'hoho'}}, false, true);
相当于：update users set age = age + 50, name = ‘hoho’ where name = ‘Lisi’;
3、删除
db.users.remove({age: 132});
4、查询修改删除
db.users.findAndModify({
query: {age: {$gte: 25}},
sort: {age: -1},
update: {$set: {name: 'a2'}, $inc: {age: 2}},
remove: true
});
db.runCommand({ findandmodify : "users",
query: {age: {$gte: 25}},
sort: {age: -1},
update: {$set: {name: 'a2'}, $inc: {age: 2}},
remove: true
});
update 或 remove 其中一个是必须的参数; 其他参数可选。
参数 | 详解 | 默认值 |
query | 查询过滤条件 | {} |
sort | 如果多个文档符合查询过滤条件，将以该参数指定的排列方式选择出排在首位的对象，该对象将被操作 | {} |
remove | 若为true，被选中对象将在返回前被删除 | N/A |
update | 一个 修改器对象 | N/A |
new | 若为true，将返回修改后的对象而不是原始对象。在删除操作中，该参数被忽略。 | false |
fields | 参见Retrieving a Subset of Fields (1.5.0+) | All fields |
upsert | 创建新对象若查询结果为空。 示例 (1.5.4+) | false |
1、简单Hello World
print("Hello World!");
这种写法调用了print函数，和直接写入"Hello World!"的效果是一样的；
2、将一个对象转换成json
tojson(new Object());
tojson(new Object('a'));
3、循环添加数据
> for (var i = 0; i < 30; i++) {
... db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
... };
这样就循环添加了30条数据，同样也可以省略括号的写法
> for (var i = 0; i < 30; i++) db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
也是可以的，当你用db.users.find()查询的时候，显示多条数据而无法一页显示的情况下，可以用it查看下一页的信息；
4、find 游标查询
>var cursor = db.users.find();
> while (cursor.hasNext()) {
printjson(cursor.next());
}
这样就查询所有的users信息，同样可以这样写
var cursor = db.users.find();
while (cursor.hasNext()) { printjson(cursor.next); }
同样可以省略{}号
5、forEach迭代循环
db.users.find().forEach(printjson);
forEach中必须传递一个函数来处理每条迭代的数据信息
6、将find游标当数组处理
var cursor = db.users.find();
cursor[4];
取得下标索引为4的那条数据
既然可以当做数组处理，那么就可以获得它的长度：cursor.length();或者cursor.count();
那样我们也可以用循环显示数据
for (var i = 0, len = c.length(); i < len; i++) printjson(c[i]);
7、将find游标转换成数组
> var arr = db.users.find().toArray();
> printjson(arr[2]);
用toArray方法将其转换为数组
8、定制我们自己的查询结果
只显示age <= 28的并且只显示age这列数据
db.users.find({age: {$lte: 28}}, {age: 1}).forEach(printjson);
db.users.find({age: {$lte: 28}}, {age: true}).forEach(printjson);
排除age的列
db.users.find({age: {$lte: 28}}, {age: false}).forEach(printjson);
9、forEach传递函数显示信息
db.things.find({x:4}).forEach(function(x) {print(tojson(x));});
2351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
