mongodb常用命令

mongodb常用命令

mongodb由C＋＋写就，其名字来自humongous这个单词的中间部分，从名字可见其野心所在就是海量数据的处理。关于它的一个最简洁描述为：scalable,high-performance,opensource,schema-free,document-orienteddatabase。MongoDB的主要目标是在键/值存储方式（提供了高性能和高度伸缩性）以及传统的RDBMS系统（丰富的功能）架起一座桥梁，集两者的优势于一身。

安装及使用：

首先在Ubuntu上安装MongoDB。

下载MongoDB,现在最新的生产版本1.7.0

1.解压文件.

$tar-xvfmongodb-linux-i686-1.4.3.tgz

2.为MongoDB创建数据目录，默认情况下它将数据存储在/data/db

$sudomkdir-p/data/db/

$sudochown`id-u`/data/db

3.启动MongoDB服务.

$cdmongodb-linux-i686-1.4.3/bin

$./mongod

4.打开另一个终端，并确保你在MongoDB的bin目录，输入如下命令.

$./mongo

概念

一个mongod服务可以有建立多个数据库，每个数据库可以有多张表，这里的表名叫collection，每个collection可以存放多个文档（document），每个文档都以BSON（binaryjson）的形式存放于硬盘中，因此可以存储比较复杂的数据类型。它是以单文档为单位存储的，你可以任意给一个或一批文档新增或删除字段，而不会对其它文档造成影响，这就是所谓的schema-free，这也是文档型数据库最主要的优点。跟一般的key-value数据库不一样的是，它的value中存储了结构信息，所以你又可以像关系型数据库那样对某些域进行读写、统计等操作。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。Mongo还可以解决海量数据的查询效率，根据官方文档，当数据量达到50GB以上数据时，Mongo数据库访问速度是MySQL10
倍以上。

BSON

BSON是BinaryJSON的简称，是一个JSON文档对象的二进制编码格式。BSON同JSON一样支持往其它文档对象和数组中再插入文档对象和数组，同时扩展了JSON的数据类型。如：BSON有Date类型和BinDate类型。

BSON被比作二进制的交换格式，如同ProtocolBuffers，但BSON比它更“schema-less”，非常好的灵活性但空间占用稍微大一点。

BSON有以下三个特点：

1．轻量级

2．跨平台

3．效率高

命名空间

MongoDB存储BSON对象到collections,这一系列的数据库名和collection名被称为一个命名空间。如同：java.util.List;用来管理数据库中的数据。

索引

mongodb可以对某个字段建立索引，可以建立组合索引、唯一索引，也可以删除索引，建立索引就意味着增加空间开销。默认情况下每个表都会有一个唯一索引：_id，如果插入数据时没有指定_id，服务会自动生成一个_id，为了充分利用已有索引，减少空间开销，最好是自己指定一个unique的key为_id，通常用对象的ID比较合适，比如商品的ID。

shell操作数据库：

1.超级用户相关：

1.#进入数据库admin

useadmin

2.#增加或修改用户密码

db.addUser('name','pwd')

3.#查看用户列表

db.system.users.find()

4.#用户认证

db.auth('name','pwd')

5.#删除用户

db.removeUser('name')

6.#查看所有用户

showusers

7.#查看所有数据库

showdbs

8.#查看所有的collection

showcollections

9.#查看各collection的状态

db.printCollectionStats()

10.#查看主从复制状态

db.printReplicationInfo()

11.#修复数据库

db.repairDatabase()

12.#设置记录profiling，0=off1=slow2=all

db.setProfilingLevel(1)

13.#查看profiling

showprofile

14.#拷贝数据库

db.copyDatabase('mail_addr','mail_addr_tmp')

15.#删除collection

db.mail_addr.drop()

16.#删除当前的数据库

db.dropDatabase()

2.增删改

1.#存储嵌套的对象

db.foo.save({'name':'ysz','address':{'city':'beijing','post':100096},'phone':[138,139]})

2.#存储数组对象

db.user_addr.save({'Uid':'yushunzhi@sohu.com','Al':['test-1@sohu.com','test-2@sohu.com']})

3.#根据query条件修改，如果不存在则插入，允许修改多条记录

db.foo.update({'yy':5},{'$set':{'xx':2}},upsert=true,multi=true)

循环批量修改记录(不存在的会添加upsert=true)

for(vari=3;i<30;i++)

{

db.tbOrder.update({_id:i},{"$set":{Name:"nameis"+i,ExTime:ISODate("2015-10-15")}},upsert=true,multi=true);

}

只会更新有的记录

for(vari=0;i<30;i++)

{

db.tbOrder.update({_id:i},{"$set":{Brnd_Name:"nameis"+i,OrderState:100,ReleaseQuantity:60}});

}

ReleaseQuantity存到数据库后可能变成double类型，ReleaseQuantity:
NumberInt("60")这样可以保存为int类型

批量更新时间（id>10000的全更新）

db.tbOrder.update({_id:{$gte:10000}},{"$set":{"ExpireTime"
:ISODate("2015-11-13T02:03:53.017Z")}},upsert=true,multi=true)

$set是局部更新,只更新指定的字段(此方法还可用于给表新增字段)

没有$setdb.tbOrder.update({_id:i},{Brnd_Name:"nameis"+i,OrderState:100,ReleaseQuantity:60});

$unset用于删除字段，下面id>-1的记录的Date,SiteId,Post三个字段都删除了

db.tbOrder.update({_id:{$gt:-1}},{$unset:{Date:1,SiteId:1,Post:1}},upsert=true,multi=true);

这样的话是整体更新，更新后该条记录只有3个字段（如果原来不止的话，其它字段就丢失了)

$inc也是局部更新
如:db.tbOrder.update({_id:1},{$inc{"age":30}})

//添加字段赋值(CreateDate赋值为UpdateDate)

db.tbOrder.find().forEach(

function(item){

db.tbOrder.update({},{"$set":{"CreateDate":item.UpdateDate}},false,true)

}

)

CityCode=hz,CreateDate
字段不存在的则添加CreateDate字段并赋值

db.tbOrder.find({CityCode:"hz","CreateDate":{$exists:false}}).forEach(

function(item){

db.tbOrder.update({CityCode:"hz","CreateDate":{$exists:false}},{"$set":{"CreateDate":item.UpdateDate}},false,true)

}

)

//列重命名

db.tbOrder.update({},{$rename:{"BigTypeName":"ParentTypeName"}},false,true)

4.#删除yy=5的记录

db.foo.remove({'yy':5})

5.#删除所有的记录

db.foo.remove()

3.索引

1.#增加索引：1(ascending),-1(descending)

2.db.foo.ensureIndex({firstname:1,lastname:1},{unique:true});

3.#索引子对象

4.db.user_addr.ensureIndex({'Al.Em':1})

5.#查看索引信息

6.db.foo.getIndexes()

7.db.foo.getIndexKeys()

8.#根据索引名删除索引

9.db.user_addr.dropIndex('Al.Em_1')

//删除索引

db.runCommand({deleteIndexes:"表名",index:"索引名"})//删除指定索引

db.foo.dropIndexes()//删除所有索引

4.查询

1.#查找所有

2.db.foo.find()

3.#查找一条记录

4.db.foo.findOne()

5.#根据条件检索10条记录

6.db.foo.find({'msg':'Hello1'}).limit(10)

7.#sort排序

8.db.deliver_status.find({'From':'ixigua@sina.com'}).sort({'Dt',-1})

9.db.deliver_status.find().sort({'Ct':-1}).limit(1)

10.#count操作

11.db.user_addr.count()

12.#distinct操作,查询指定列，去重复

13.db.foo.distinct('msg')

14.#”>=”操作

15.db.foo.find({"timestamp":{"$gte":2}})

16.#子对象的查找

17.db.foo.find({'address.city':'beijing'})

//查找不存在字段FName的记录

db.foo.find({CityCode:"hz","FName":{$exists:false}})

18数组数据查询：

--基于数组的查找。

>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"]}

5.管理

1.#查看collection数据的大小

2.db.deliver_status.dataSize()

3.#查看colleciont状态

4.db.deliver_status.stats()

5.#查询所有索引的大小

6.db.deliver_status.totalIndexSize()

6.advancedqueries:高级查询

条件操作符

>,>=,<,<=,!=,对应"$gt","$gte","$lt",
"$lte","$ne"

OR，In，NotIn对应"$or","$in"，"$nin"

查询name<>"bruce"andage>=18的数据

db.users.find({name:{$ne:"bruce"},age:{$gte:
18}});

查询creation_date>'2010-01-01'andcreation_date<='2010-12-31'的数据

db.users.find({creation_date:{$gt:newDate(2010,0,1),$lte:new
Date(2010,11,31)});

查询agein(20,22,24,26)的数据

db.users.find({age:{$in:[20,22,24,26]}});

查询age取模10等于0的数据

db.users.find('this.age%10==0');

或者

db.users.find({age:{$mod:[10,0]}});

匹配所有

db.users.find({favorite_number:{$all:[6,8]}});

可以查询出{name:'David',age:26,favorite_number:[6,8,9]}

可以不查询出{name:'David',age:26,favorite_number:[6,7,9]}

查询不匹配name=B*带头的记录

db.users.find({name:{not:/^B.*/}});查询age取模10不等于0的数据db.users.find({age:{not:
{$mod:[10,0]}}});

#返回部分字段

选择返回age和_id字段(_id字段总是会被返回)

db.users.find({},{age:1});

db.users.find({},{age:3});

db.users.find({},{age:true});

db.users.find({name:"bruce"},{age:1});

0为false,非0为true

选择返回age、address和_id字段

db.users.find({name:"bruce"},{age:1,address:1});

排除返回age、address和_id字段

db.users.find({},{age:0,address:false});

db.users.find({name:"bruce"},{age:0,address:false});

数组元素个数判断

对于{name:'David',age:26,favorite_number:[6,7,9]}记录

匹配db.users.find({favorite_number:{size:3}});不匹配db.users.find({favorite_number:{size:
2}});

exists判断字段是否存在查询所有存在name字段的记录db.users.find({name:{exists:
true}});

查询所有不存在phone字段的记录

db.users.find({phone:{$exists:false}});

type判断字段类型查询所有name字段是字符类型的db.users.find({name:{type:
2}});

查询所有age字段是整型的

db.users.find({age:{$type:16}});

对于字符字段，可以使用正则表达式

查询以字母b或者B带头的所有记录

db.users.find({name:/^b.*/i});

$elemMatch(1.3.1及以上版本)

为数组的字段中匹配其中某个元素

Javascript查询和where查询查询age>18的记录，以下查询都一样db.users.find({age:{$gt:
18}});

db.users.find({$where:"this.age>18"});

$where也可以这样写：

db.users.find({$where:function(){returnthis._id>18||this._id<5}});

db.users.find("this.age>18");

f=function(){returnthis.age>18}db.users.find(f);(有问题，？)

排序sort()

以年龄升序asc

db.users.find().sort({age:1});

以年龄降序desc

db.users.find().sort({age:-1});

限制返回记录数量limit()

返回5条记录

db.users.find().limit(5);

返回3条记录并打印信息

db.users.find().limit(3).forEach(function(user){print('myageis'+user.age)});

结果

myageis18

myageis19

myageis20

限制返回记录的开始点skip()

从第3条记录开始，返回5条记录(limit3,5)

db.users.find().skip(3).limit(5);

查询记录条数count()

db.users.find().count();

db.users.find({age:18}).count();

以下返回的不是5，而是user表中所有的记录数量

db.users.find().skip(10).limit(5).count();

如果要返回限制之后的记录数量，要使用count(true)或者count(非0)

db.users.find().skip(10).limit(5).count(true);

分组group()

假设test表只有以下一条数据

{domain:"www.mongodb.org"

,invoked_at:{d:"2009-11-03",t:"17:14:05"}

,response_time:0.05

,http_action:"GET/display/DOCS/Aggregation"

}

使用group统计test表11月份的数据count:count(*)、total_time:sum(response_time)、avg_time:total_time/count;

db.test.group(

{cond:{"invoked_at.d":{$gt:"2009−11",$lt:
"2009-12"}}

,key:{http_action:true}

,initial:{count:0,total_time:0}

,reduce:function(doc,out){out.count++;out.total_time+=doc.response_time}

,finalize:function(out){out.avg_time=out.total_time/out.count}

});

[

{

"http_action":"GET/display/DOCS/Aggregation",

"count":1,

"total_time":0.05,

"avg_time":0.05

}

]

use<dbname>：切换当前数据库，这和MS-SQL里面的意思一样

db.help()：显示数据库操作命令，里面有很多的命令

db.foo.help()：显示集合操作命令，同样有很多的命令，foo指的是当前数据库下，一个叫foo的集合，并非真正意义上的命令

db.foo.find()：对于当前数据库中的foo集合进行数据查找（由于没有条件，会列出所有数据）

db.foo.find({a:1})：对于当前数据库中的foo集合进行查找，条件是数据中有一个属性叫a，且a的值为1

MongoDB没有创建数据库的命令，但有类似的命令。

如：如果你想创建一个“myTest”的数据库，先运行usemyTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。

数据库常用命令

1、Help查看命令提示

help

db.help();

db.yourColl.help();

db.youColl.find().help();

rs.help();

5、从指定主机上克隆数据库

db.cloneDatabase(“127.0.0.1”);将指定机器上的数据库的数据克隆到当前数据库

6、从指定的机器上复制指定数据库数据到某个数据库

db.copyDatabase("mydb","temp","127.0.0.1");将本机的mydb的数据复制到temp数据库中

7、修复当前数据库

db.repairDatabase();

8、查看当前使用的数据库

db.getName();

db;db和getName方法是一样的效果，都可以查询当前使用的数据库

9、显示当前db状态

db.stats();

10、当前db版本

db.version();

11、查看当前db的链接机器地址

db.getMongo();

Collection聚集集合

1、创建一个聚集集合（table）

db.createCollection(“collName”,{size:20,capped:5,max:100});

2、得到指定名称的聚集集合（table）

db.getCollection("account");

3、得到当前db的所有聚集集合

db.getCollectionNames();

4、显示当前db所有聚集索引的状态

db.printCollectionStats();

其他

1、查询之前的错误信息

db.getPrevError();

2、清除错误记录

db.resetError();

语句块操作

1、简单HelloWorld

print("HelloWorld!");

这种写法调用了print函数，和直接写入"HelloWorld!"的效果是一样的；

2、将一个对象转换成json

tojson(newObject());

tojson(newObject('a'));

3、循环添加数据

>for(vari=0;i<30;i++){

...db.users.save({name:"u_"+i,age:22+i,sex:i%2});

...};

这样就循环添加了30条数据，同样也可以省略括号的写法

>for(vari=0;i<30;i++)db.users.save({name:"u_"+i,age:22+i,sex:i%2});

也是可以的，当你用db.users.find()查询的时候，显示多条数据而无法一页显示的情况下，可以用it查看下一页的信息；

4、find游标查询

>varcursor=db.users.find();

>while(cursor.hasNext()){

printjson(cursor.next());

}

这样就查询所有的users信息，同样可以这样写

varcursor=db.users.find();

while(cursor.hasNext()){printjson(cursor.next);}

同样可以省略{}号

5、forEach迭代循环

db.users.find().forEach(printjson);

forEach中必须传递一个函数来处理每条迭代的数据信息

6、将find游标当数组处理

varcursor=db.users.find();

cursor[4];

取得下标索引为4的那条数据

既然可以当做数组处理，那么就可以获得它的长度：cursor.length();或者cursor.count();

那样我们也可以用循环显示数据

for(vari=0,len=c.length();i<len;i++)printjson(c[i]);

7、将find游标转换成数组

>vararr=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));});

查询补充

>,>=,<,<=查询

查询某个字段比指定值小:$lt

//假设存在集合USERdb.USER.find({REGIST_DATE:{$lt:newDate(2013,0,1)}});

/*前面提到过mongo完全遵守J***ASCRIPT语法，在J***ASCRIPT里面，月份是从0开始的，即上面的查询是查询2013-1-1以前注册的的用户。*/

查询某个字段比指定值大:$gt

db.USER.find({REGIST_DATE:{$gt:newDate(2013,0,1)}});

/*$lt表示小于，表示大于的自然就是$gt了*/

大于等于:$gte小于等于:$lte

db.USER.find({REGIST_DATE:{$gte:newDate(2013,0,1),$lte:newDate(2013,0,31)}});

/*关于这个时间的问题看起来似乎有些别扭哈，没办法啦，MONGO就是这样啦。习惯就好啦。*/

/*上面的一行查询就是针对REGIST_DATE的组合查询形式，表示查询出所有在2013-1-1到2013-1-31注册的用户*/



[b]正则表达式[/b]

正则表达式，mongo里面没有类似sql的like特性，不过可以用正则表达式代替

使用正则表达式查询有两种情况，在支持正则表达式字面值（标量）的语言里可以直接使用正则表达式字面值，比如RUBYNODEJS等。

db.USER.find({NAME:/^run/i});//以javascript为例，这个查询出所有用户名以run开头的用户，且不分大小写

像J***A这样不支持正则表达式标量的语言怎么办呢？就有些麻烦了，需要借助MONGOapi完成从字符串到正则表达式的转化。

db.USER.find(NAME:{$regex:'^run',$options:'i'});//这行命令完成跟上一行一样的工作。

其中，$options是正则表达式的选项，它一共有三个字母的任意组合可选，这三个字母分别是gim，这三个字母可以任意组合表达不同的意义。

g：表示针对整个字符串做匹配，如果不加正则表达式在匹配到第一个符合的子串时就返回了。(global)

i：忽略大小写(insenssitive)

m：一个字符串内如果存在换行符，将作为多行模式匹配（multiple）

除了i以外其它两个选项在查询的时候恐怕用不到。


[b]$in---相当于sql的in，它可以利用索引

[/b]

db.USER.find(NAME:{$in:['tom','jerry']});

/*如果为NAME字段创建了索引，它就会从索引里面查找*/

/*mongo是区分大小写的，所以集合和文档属性的名字必须与创建它们的时候一致。*/

/*也就是NAME和name是两个不同的属性，它们可以同时存在于一个文档内*/

/*在一个集合内如果即存在NAME属性的文档，又存在name属性的文档，那么上面的那条命令不会把name属性查询出来*/

$nin---$in的相反操作，相当于sql的notin

db.USER.find(NAME:{$nin:['tom','jerry']});

注意：$nin不会利用索引，也就是说上面的命令$nin不会使用针对NAME属性的索引。


[b]$all[/b]

$all---没有sql类似的特性与之类比了，它的意义在于：查询条件是一个简单值数组，只有返回属性满足数组内的所有值的文档。这种查询条件只有在属性值是一个数组的情况下。

以我的这篇博文为例。要查询出所有含有nosql和mongo这两个标签的文档可以这么做

假设iteye要把数据库迁移到mongo，博客文章的数据模型就可以这样定义

首先定义一个名为blog的集合。

这篇blog可以如下方式存储

{

_ID:ObjectID(............),

subject:'mongo简介——查询（续）',

category:'database',

user_category:['nosql','mongo'],

content:'.............',

tags:['nosql','mongo'],

origrinal:true,

pub:'blog'

}

/*origrinal表示是否原创；由于没有附件，本文的文档就不包含附件属性，由于我不知道iteye如何定义频道，我就用字符串表示了*/

下面如果要查询包含‘nosql’标签的所有博文

db.blog.find(tags:'nosql');//这样就可以了

下面要查询同时包含'nosql'和'mongo'这两个标签的博文

db.blog.find(tags:{$all:['nosql','mongo']});

如果有的博文除了包含'nosql'和'mongo'标签，还包含'MONGO''Mongo''mongodb''MongoDB'‘NOSQL’等标签，上面的那行命令也会一起返回。

如果要进行忽略大小写的查询，我又不想使用正则表达式做模糊匹配该怎么办呢？

答案是不能。

而这样的需求还是很常见的，那么惟一的做法就是，在用户保存博文的时候，程序根据以前已经存在的标签找出相似词，自动创建几个可能会出现的不同大小写的标签。比如我保存这篇文章的时候程序再自动创建上面提到的那几个我没有指定的标签。


[b]$ne---不等性比较，它接收单值或数组[/b]

db.blog.find(tags:{$ne:'nosql'});//返回所有不包含nosql标签的博文

db.blog.find(tags:{$ne:['nosql','mongo']});//返回所有不包含nosql和mongo这两个标签的博文


$size

$size---检查一个数组的尺寸，不利用索引，不能做范围查询，以后可能会增加这方面的支持

有时iteye会给用户快递一些奖品，iteye可能会把用户曾经填过的地址保存下来。可以这么保存

在USER集合里增加一个address属性，没有留过地址的可以没有。

一个用户不一定只有一个地址，这个address就可以创建为一个字符串数组。

比如要返回所有只留了一个地址的用户。

db.USER.find(address:{$size:1});

有些时候，如果ITEYE想要知道用户更详细的地址信息，就要用更复杂的文档保存地址。比如：

{

_ID:ObjectID(.........),

accountName:'runfriends',

address:[{category:'home',city:'北京',district:'东城',street:'.....'},

{category:'company',city:'北京',district:'海淀',street:'........'}]

}

如果要查出所有家在北京的用户，要怎么做呢？

可能会这样写：

db.USER.find({'address.category':'home','address.city':'北京'})。

但是这样是错的！这行命令的意义是查询出所有地址里面分类包含home，而且地址所在城市包含北京的用户。有些用户的公司地址在北京，而家庭地址不是，这些用户也会被匹配到。

[b]$elemMatch[/b]

那么接下来就用到了$elemMatch

它只在需要匹配子文档的多个属性时才会用到

db.USER.find(address:{$elemMatch:{category:'home',city:'北京'}});

[b]$not[/b]

$not---取反值，只有在没有指定相反操作时才需要用到它。因为绝大部分操作符都有对应的相反操作，所以应当尽量使用相反操作符，比如正则表达式匹配没有相反操作

假如有一天，ITEYE只允许用户名以字母开头了就可以把所有不以字母开头的用户查出来给他们发一封邮件，让他们改名。

db.USER.find(accountName:{$not:/^[a-zA-Z]/})

当然$not也接收单值，但是不建议使用


[b]$exists[/b]

$exists----检查某个属性的存在性。

比如要把所有包含附件的博文查询出来。

db.blog.find({attachment:{$exists:true}});

没有附件的就是db.blog.find({attachment:{$exists:false}});

或才可以这样做：

db.log.find({attachment:null});//不存在

db.blog.find({attachment:{$ne:null}});//存在

前面介绍BSON的时候说过空值使用nil，但是这里却用了null，是因为nil是BSON的定义，这里是J***ASCRIPT的语法


[b]$mod-----求余数，不利用索引[/b]

假如说某天ITEYE心血来潮要给所有年龄能被4整队的用户快递一份奖品。

db.USER.find({age:{$mod:[4,0]}});//数组的第一个值是除数，第二个值是期望的余数


[b]$type---以属性类型查询[/b]

虽然不建议在同一集合的不同文档相同属性名保存着不同类型的数据，但是有时由于程序bug或设计不严谨可能会出现这种情况。现在要把这种情况找出来，比如_ID属性有的是ObjectID类型，有的是整数。下面把所有_ID是字符串的文档找出来。

db.USER.find(_id:{$type:2})

db.USER.find(_id:{$not:{$type:7}});//把所有主键ObjectID类型的文档找出来


[b]$or$and----逻辑运算[/b]

它们的意义就不多解释了。不过它们的用法非常有意思

比如找出所有月收入在20000以上或2000以下的用户

db.USER.find({$or:[{salary:{$gt:20000}},{salary:{$lt:2000}}]});

找出所有月收入在8000以上，20000以下的用户

db.USER.find({$and:[{salary:{$gte:8000}},{salary:{$lte:20000}}]});


[b]查询嵌套文档和数组元素[/b]

前面的内容已经简单介绍一些嵌套文档和数组元素的查询。嵌套文档和数组的查询遵守相同的语法规则

1.它们都采用点号分割嵌套文档的属性，如果是数组的索引就用从0开始的数字表示。

db.USER.find({'address.category':'home'});//这个是查出所有留了家庭地址的用户

如果想知道用户留下的第一个地址是不是家庭地址可以这么做：

db.USER.find({'address.0.category':'home'});

那么如果想只返回留了家庭地址的用户而又只返回家庭地址却不返回其它的地址该怎么做呢？

目前采用的数据模型恐怕做不到这一点，如果有这样的需求，恐怕只能为不同的地址定义不同的字段了。

当然如果代码规范规定第一个地址必须是家庭地址，那么可以这样做：

db.USER.find({'address.0.category':'home'},{'accountName':1,'address.0':1});

不过通常情况下，把第一个地址定义为默认地址更好一些。


[b]$where-----接收一段javascript代码作为查询条件，不利用索引[/b]

假如说要查询所有闰年出生的用户

db.USER.find({$where:'varyear=birthday.getFullYear();returnyear%4==0&&year%100>0||year%400==0';});

或：

db.USER.find($where:'function(){varyear=this.birthday.getFullYear();returnyear%4==0&&year%100>0||year%400==0'}');

更多的命令可看官方文档http://docs.mongodb.org/manual/reference/method/db.getMongo/