mongodb2

$exists

判断一个域是否存在

查找存在hobby域的文档

> db.class1.find({hobby:{$exists:true}},{_id:0})
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
>

查找不存在hobby域的文档

> db.class1.find({hobby:{$exists:false}},{_id:0})
{ "name" : "lily", "age" : 17 }
>

$mod

做除数余数查找

查找，age能被2除，余数为1 的文档

> db.class1.find({age:{$mod:[2,1]}},{_id:0})
{ "name" : "lily", "age" : 17 }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
>

￥type

查找指定数据类型的文档

Type	Number	Alias	Notes
Double	1	“double”
String	2	“string”
Object	3	“object”
Array	4	“array”
Binary data	5	“binData”
Undefined	6	“undefined”	Deprecated.
ObjectId	7	“objectId”
Boolean	8	“bool”
Date	9	“date”
Null	10	“null”
Regular Expression	11	“regex”
DBPointer	12	“dbPointer”	Deprecated.
JavaScript	13	“javascript”
Symbol	14	“symbol”	Deprecated.
JavaScript (with scope)	15	“javascriptWithScope”
32-bit integer	16	“int”
Timestamp	17	“timestamp”
64-bit integer	18	“long”
Decimal128	19	“decimal”	New in version 3.4.
Min key	-1	“minKey”
Max key	127	“maxKey”

> db.class1.find({hobby:{$type:2}},{_id:0})
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
>https://docs.mongodb.com/manual/reference/operator/query/type/index.html

进一步的信息筛选

distinct()

功能：查看一个集合中某个域值的覆盖范围（去除相同项）

> db.class1.distinct('age')
[ 17, 35, 56, 55 ]

> db.class1.distinct('hobby')
[ "吃饭", "打豆豆", "睡觉", "看戏", "喝酒", "打飞机", "二人转" ]
>

pretty()

功能：查询结果，格式化显示

> db.class1.find().pretty()
{
"_id" : ObjectId("5d2d651f054ccfda64df9a35"),
"name" : "lily",
"age" : 17
}
{
"_id" : ObjectId("5d2ed0c9226651eee5c79df3"),
"name" : "刘英",
"age" : 35,
"hobby" : [
"吃饭",
"睡觉",
"打豆豆"
]
}

limit()

功能：查询结果显示前n条

> db.class1.find({},{_id:0}).limit()
{ "name" : "lily", "age" : 17 }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
> db.class1.find({},{_id:0}).limit(3)
{ "name" : "lily", "age" : 17 }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
>

skip(n)

功能：显示时跳过前N条

> db.class1.find({},{_id:0}).skip(0)
{ "name" : "lily", "age" : 17 }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
> db.class1.find({},{_id:0}).skip(3)
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
>

count()

功能：对查找结果计数统计

> db.class1.find({},{_id:0}).count()
5
> db.class1.find({age:55},{_id:0}).count()
2
>

sort({键：1/-1})

功能：对查找结果排序

1表示按照升序排列，-1表示按照降序排列

> db.class1.find({age:{$exists:true}},{_id:0}).sort({age:1})-----升序排
{ "name" : "lily", "age" : 17 }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
> db.class1.find({age:{$exists:true}},{_id:0}).sort({age:-1})------------降序排列
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "lily", "age" : 17 }
>

复合排序：当age出现相同时，按照name的降序排序

> db.class1.find({age:{$exists:true}},{_id:0}).sort({age:-1,name:-1})
{ "name" : "赵四", "age" : 56, "hobby" : [ "吃饭", "睡觉", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "lily", "age" : 17 }
>

函数的连续使用

查找年龄最小的三个

> db.class1.find({},{_id:0}).sort({age:1}).limit(3)
{ "name" : "lily", "age" : 17 }
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
>

删除文档：

db.collectionName.remove(query,justOne)

功能；删除指定的文档

参数；query;筛选要删除的文档，类似where子句

　　　　　　用法同查找操作

　　　　justOne:布尔值，默认 false 表示删除所有筛选数据

　　　　　　　　如果赋值为true，则表示只删除第一条复合的文档

删除没有hobby或age大于55的文档

> db.class1.remove({$or:[{hobby:{$exists:false}},{age:{$gt:55}}]})
WriteResult({ "nRemoved" : 2 })
> db.class1.find({},{_id:0})
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "刘能", "age" : 55, "hobby" : [ "喝酒", "打飞机", "看戏" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }

>

删除age等于55 的第一条语句，

> db.class1.remove({age:{$eq:55}},true)-------由于true参数的存在，只删除了第一条语句，否则会                                                                               删除两条age等于55的语句

WriteResult({ "nRemoved" : 1 })
> db.class1.find({},{_id:0})
{ "name" : "刘英", "age" : 35, "hobby" : [ "吃饭", "睡觉", "打豆豆" ] }
{ "name" : "广坤", "age" : 55, "hobby" : [ "二人转", "喝酒" ] }
>

删除集合中所有的文档

db.collectionName.remove({})注意要有{}

> db.class0.remove({})
WriteResult({ "nRemoved" : 11 })
>

hobby中即什么又什么可以用$all

> db.class1.find({hobby:{$all:["打飞机","睡觉"]}},{_id:0})
{ "name" : "玉田", "age" : 28, "hobby" : [ "打飞机", "睡觉", "吃饭" ] }
>

修改数据：

db.collectionName.update(query,update,upsert,multi)

功能：修改一个文档

参数：query:筛选要修改的文档，相当于where子句

　　　　　　用法同查找

　　　　update:将数据更新成什么内容，相当于set操作

　　　　　　　　需要使用修改器操作符

　　　　upsert:bool值，默认为false 表示如果query的文档不存在，则无法修改

　　　　　　　如果设置为true，表示如果query的文档不存在，则根据query和update参数插入新                            的文档

　　　　multi：bool值，默认为false.表示如果有多条符合筛选条件的文档，则只修改第一条

　　　　　　　如果设置true，则修改所有符合条件的文档

设置刘英的年龄为31：

> db.class1.update({name:'刘英'},{$set:{age:31}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

update可以插入一条新的文档，注意要有true，否则不会

> db.class1.update({name:'小刘英'},{$set:{age:11}},true)
WriteResult({
"nMatched" : 0,
"nUpserted" : 1,
"nModified" : 0,
"_id" : ObjectId("5d301d939646724b48d62ae5")
})

修改器操作符：

1、$set

修改一个域的值；

还可以增加一个域

小刘英开始没有hobby域

> db.class1.update({name:'小刘英'},{$set:{hobby:['看书','学习']}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

$unset

删除一个域

删除玉田的age域，age:0是语法需要，习惯是写0，其他数字也可以

> db.class1.update({name:'玉田'},{$unset:{age:0}})

$rename

修改一个域的名称

把"age"修改成‘’Age‘’

> db.class1.update({},{$rename:{age:'Age'}},false,true)

$setOnInsert

如果update操作插入新的文档，则补充插入内容

刘能在之前的没有

> db.class1.update({name:'刘能'},{$set:{hobby:['喝酒','吹牛']},$setOnInsert:{Age:60,telephone:138}},true)

$inc

加减修改器

年龄-2

> db.class1.update({Age:{$gt:55}},{$inc:{Age:-1}},false,true)

$mul 

乘法修改器

可以乘以正数、负数、小数

小刘英年龄乘以2

> db.class1.update({name:'小刘英'},{$mul:{age:2}})

$min

设定最小值：如果筛选的文档指定的域值小于min值，则不修改；

　　　　　　如果大于min值，则改为min值,

刘能的年龄是59，大于min(55),所以最后只有他的年龄改成了55

> db.class1.update({},{$min:{Age:55}},false,true)

$max

设置最大值：如果筛选的文档的值域大于max，则不修改；

　　　　　　　如果小于max值，则改为max值

> db.class1.update({},{$max:{Age:24}},false,true)

数组修改器

$push增加

> db.class1.update({name:'刘能'},{$push:{hobby:'打麻将'}})

$pushAll

添加多项

 $each 逐个操作

> db.class1.update({name:'广坤'},{$push:{hobby:{$each:['抽烟','烫头']}}})

position:

选择数据位置进行操作，必须和each合用

> db.class1.update({name:'谢大脚'},{$push:{hobby:{$each:['跳舞','唱歌'],$position:1}}})

$sort：

对数组进行排序，必须和each合用

each[]表示没有插入，只排序  1表示升序；-1表示降序

> db.class1.update({name:'谢大脚'},{$push:{hobby:{$each:[],$sort:-1}}})

$pull

从数组中删除一个元素

> db.class1.update({name:'广坤'},{$pull:{hobby:'二人转'}})

$pullAll

从数组中删除多个元素

db.class1.update({name:'广坤'},{$pullAll:{hobby:['喝酒','烫头']}})

$pop

弹出(删除)数组中的一项（第一项或者最后一项）1表示最后一项；-1表第一项

> db.class1.update({name:'玉田'},{$pop:{hobby:1}})

$addToSet

向数组中插入一个元素，但是该元素不能和其他元素重复

如果之前没有烫头，插入烫头；如果之前有，不会在插入

但是push,就可以插入烫头，即使之前有烫头，就会变成两个烫头

> db.class1.update({name:'广坤'},{$addToSet:{hobby:'烫头'}})

数据类型：

时间类型 mongo中存储时间的格式：ISODate(当前时间)

> db.class0.insert({day:new Date()})
WriteResult({ "nInserted" : 1 })
> db.class0.find({},{_id:0})
{ "day" : ISODate("2019-07-19T03:16:52.187Z") }
>

> db.class0.insert({day:Date()})
WriteResult({ "nInserted" : 1 })
> db.class0.find({},{_id:0})
{ "day" : ISODate("2019-07-19T03:16:52.187Z") }
{ "day" : ISODate("2019-07-19T04:19:25.349Z") }
{ "day" : "Fri Jul 19 2019 12:22:02 GMT+0800 (CST)" }
>

指定时间的转换：

ISODate()

功能：生成mongo时间类型

参数：如果不加参数，怎生成当前时间

　　　　参数格式：‘’2019-10-10 10:10:10"

　　　　　　　　　　20191001 10:10:10

　　　　　　　　　　"20190102"

> db.class0.insert({title:'python',day:ISODate('20190101 11:09:07')})

时间戳获取：

1970-01-01 00:00：00到现在的秒数

> db.class0.insert({title:'python',day:ISODate().valueOf()})

{ "title" : "python", "day" : 1563514740935 }

null:

1、如果某个域存在，却没有值，可以设置为null；

> db.class1.insert({name:"大老乃",hobby:null})

2、表示某个域不存在，可以通过null进行匹配

> db.class1.find({Age:null},{_id:0})
{ "name" : "大老乃", "hobby" : null }

object类型（值是一个文档）

当使用外层文档引用内部文档的时候，可以使用“.”的方法引用

注意使用时需要加上引号

> db.class1.insert({name:'王天来',faimly:{father:'王大拿',mother:'谢大脚'}})
WriteResult({ "nInserted" : 1 })
> db.class1.find({'faimly.father':'王大拿'},{_id:0})
{ "name" : "王天来", "faimly" : { "father" : "王大拿", "mother" : "谢大脚" } }
>

修改

> db.class1.update({name:'王天来'},{$set:{'faimly.father':'刘能'}})

数组的下标引用

使用一个数组时，可以使用‘.’序列下标的方式，使用数组具体的某一项

同样需要引号

> db.class1.update({name:'玉田'},{$set:{'hobby.0':'打豆豆'}})

文档查找结果的有序性

可以通过[]取查找结果序列的某一项

> db.class1.find({},{_id:0})[1]

索引：

是建立指定键值及所在文档中存储位置的对照清单。使用索引可以方便我们进行快速查找，减少遍历次数，提高查找效率。

mongo中如何创建索引

ensureIndex()

功能：创建索引

参数：索引类别，索引选项 

1表示为该域创建正向索引；

-1表示逆向索引

_id域会自动创建索引

> db.class1.ensureIndex({name:1})

查看索引

> db.class1.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "stu.class1"
},
{
"v" : 2,
"key" : {
"name" : 1
},
"name" : "name_1",
"ns" : "stu.class1"
}
]

删除索引

通过索引名称或者索引键值对删除索引

> db.class1.dropIndex('name_1')

或db.class1.dropIndex({name:1})

dropIndexes()

功能：删除一个集合中的所有索引

db.class1.dropIndexes()

索引类型：

复合索引：根据多个域创建一个索引

当查询时，经常需要2个域条件时，才能查找结果，使用复合索引，效率会比单独2个域索引，效率要高。

> db.class1.ensureIndex({name:1,Age:-1})

> db.class1.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "stu.class1"
},
{
"v" : 2,
"key" : {
"name" : 1,
"Age" : -1
},
"name" : "name_1_Age_-1",
"ns" : "stu.class1"
}
]
>

数组索引：

如果 对某个数组域创建索引，那么表示对数组中的每个值均创建了索引，这时候通过数组中单个值查询，也是索引查询

子文档索引：

1、如果对一个域创建索引，此时值是一个文档，则改文档也会创建索引，对子文档中的域进行查找时，也会提高效率

db.class1.ensureIndex({faimly:1})

2、如果对一个域中子文档的域创建索引，索引只是针对子文档的域有效果

db.class1.ensureIndex{‘’faimly.father”:1}

例如

{ "name" : "王天来", "faimly" : { "father" : "刘能", "mother" : "谢大脚}

覆盖索引

查找时只获取索引项的内容，二不必去获取原数据中的其他内容，这样就不去连接原有的数据，直接返回即可。

name为索引项，显示也只显示name域

> db.class1.find({name:'玉田'},{_id:0,name:1})
{ "name" : "玉田" }
>

唯一索引

创建索引时，希望索引域的值均不相同，也可以据此限制一个域的值；

当对某域创建了唯一索引后，不允许再插入相同的值的文档。

> db.class1.ensureIndex({name:1},{unique:true})

稀疏索引（间隙索引）：

只针对有指定域的文档创建索引表，没有改域的文档，不会插入到索引表中

> db.class1.ensureIndex({Age:1},{sparse:true})

索引约束：

1、影响数据的插入、删除、修改操作。当数据发生改变时，索引表必须同步更新

2、索引也需要占用一定的空间资源

====================================================

*1、当数据库大量的操作是插入、修改、删除操作，而非查询操作，不适合创建索引；

2、当数据量比较小时，考虑空间成本，也不适合创建索引

3、即使创建索引，也并不是索引越多越好。