MongoDB

关系型和非关系型的介绍

1.之前用MySQL时需要实现设计各种复杂的表结构（例如 一对一、多对一、多对多等），而使用NoSQL则省去了这个环节，以MongoDB为例 存储数据的方式就像Python中的字典一样，非常方便
2.对于关系型数据库，存储数据的时候需要提前建表建库，随着数据的复杂度越来越高，所建的表的数量也越来越多；但是非关系型却不需要'

NoSQL有哪些常用的数据库

Redis
MemCache(内存型数据库，与redis有些相似，具体自行谷歌、百度查询)
MongoDB

RDBMS 对比 NoSQL

 RDBMS：关系数据库管理系统（Relational Database Management System
 NoSQL，泛指非关系型的数据库



RDBMS
	高度组织化结构化数据
	结构化查询语言（SQL）
	数据和关系都存储在单独的表中
	事务
#NoSQL
	代表着不仅仅是SQL
	没有声明性查询语言
	没有预定义的模式
	键 - 值对存储
	最终一致性，而非ACID属性
	非结构化和不可预知的数据
	高性能，高可用性和可伸缩性

Memcached与Redis有什么区别

Redis 和 Memcached 都是基于内存的数据存储系统。Memcached是高性能分布式内存缓存服务，其本质上就是一个内存key-value数据库。Redis是一个开源的key-value存储系统。与Memcached类似，Redis将大部分数据存储在内存中，支持的数据类型包括：字符串、哈希表、链表、集合、有序集合以及基于这些数据类型的相关操作。那么，Memcached与Redis有什么区别呢？让我们一起来看一下。

1、数据操作不同

与Memcached仅支持简单的key-value结构的数据记录不同，Redis支持的数据类型要丰富得多。Memcached基本只支持简单的key-value存储，不支持枚举，不支持持久化和复制等功能。Redis支持服务器端的数据操作相比Memcached来说，拥有更多的数据结构和并支持更丰富的数据操作，支持list、set、sorted set、hash等众多数据结构，还同时提供了持久化和复制等功能。而通常在Memcached里，使用者需要将数据拿到客户端来进行类似的修改再set回去，这大大增加了网络IO的次数和数据体积。在Redis中，这些复杂的操作通常和一般的GET/SET一样高效。所以，如果需要缓存能够支持更复杂的结构和操作， Redis会是更好的选择。

 

2、内存管理机制不同

在Redis中，并不是所有的数据都一直存储在内存中的。这是和Memcached相比一个最大的区别。当物理内存用完时，Redis可以将一些很久没用到的value交换到磁盘。Redis只会缓存所有的key的信息，如果Redis发现内存的使用量超过了某一个阀值，将触发swap的操作，Redis根据“swappability = age*log(size_in_memory)”计算出哪些key对应的value需要swap到磁盘。然后再将这些key对应的value持久化到磁盘中，同时在内存中清除。这种特性使得Redis可以保持超过其机器本身内存大小的数据。

 

而Memcached默认使用Slab Allocation机制管理内存，其主要思想是按照预先规定的大小，将分配的内存分割成特定长度的块以存储相应长度的key-value数据记录，以完全解决内存碎片问题。

 

从内存利用率来讲，使用简单的key-value存储的话，Memcached的内存利用率更高。而如果Redis采用hash结构来做key-value存储，由于其组合式的压缩，其内存利用率会高于Memcached。

 

3、性能不同

由于Redis只使用单核，而Memcached可以使用多核，所以平均每一个核上Redis在存储小数据时比Memcached性能更高。而在100k以上的数据中，Memcached性能要高于Redis，虽然Redis也在存储大数据的性能上进行了优化，但是比起Memcached，还是稍有逊色。

 

4、集群管理不同

Memcached是全内存的数据缓冲系统，Redis虽然支持数据的持久化，但是全内存毕竟才是其高性能的本质。作为基于内存的存储系统来说，机器物理内存的大小就是系统能够容纳的最大数据量。如果需要处理的数据量超过了单台机器的物理内存大小，就需要构建分布式集群来扩展存储能力。

 

Memcached本身并不支持分布式，因此只能在客户端通过像一致性哈希这样的分布式算法来实现Memcached的分布式存储。相较于Memcached只能采用客户端实现分布式存储，Redis更偏向于在服务器端构建分布式存储。

 

小结：Redis和Memcached哪个更好？

Redis更多场景是作为Memcached的替代者来使用，当需要除key-value之外的更多数据类型支持或存储的数据不能被剔除时，使用Redis更合适。如果只做缓存的话，Memcached已经足够应付绝大部分的需求，Redis 的出现只是提供了一个更加好的选择。总的来说，根据使用者自身的需求去选择才是最合适的。

MongoDB的介绍

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。

在高负载的情况下，添加更多的节点，可以保证服务器性能。

MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。

MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组

MongoDB的优势

1.易扩展： NoSQL数据库种类繁多， 但是⼀个共同的特点都是去掉关系数据库的关系型特性。 数据之间⽆关系， 这样就⾮常容易扩展
2.⼤数据量， ⾼性能： NoSQL数据库都具有⾮常⾼的读写性能， 尤其在⼤数据量下， 同样表现优秀。 这得益于它的⽆关系性， 数据库的结构简单
3.灵活的数据模型： NoSQL⽆需事先为要存储的数据建⽴字段， 随时可以存储⾃定义的数据格式。 ⽽在关系数据库⾥， 增删字段是⼀件⾮常麻烦的事情。 如果是⾮常⼤数据量的表， 增加字段简直就是⼀个噩梦

MongoDB的安装

sudo apt-get install -y mongodb

MongoDB的启动

1.服务端的启动
	查看mongodb是什么样的状态：ps -aux|grep mongodb

	启动: sudo service mongodb start
	停止: sudo service mongodb stop
	重启: sudo service mongodb restart
	配置文件的位置：/etc/mongodb.conf
	日志的位置：/var/log/mongodb/mongod.log
	默认端⼝：27017
	查看未注释的内容：grep -v "#" mongodb.conf
	查看注释的内容：grep v "#" mongodb.conf
2. 客户端的启动
	启动本地客户端:mongo
	查看帮助：mongo –help
	退出：exit或者ctrl+c

Mongodb的权限管理

1 为什么要进行权限管理的设置
刚安装完毕的mongodb默认不使用权限认证方式启动，与MySQL不同，mongodb在安装的时候并没有设置权限，然而公网运行系统需要设置权限以保证数据安全，所以我们要学习mongodb的权限管理

2 mongodb的权限管理方案

MongoDB是没有默认管理员账号，所以要先添加管理员账号，并且mongodb服务器需要在运行的时候			开启验证模式
	用户只能在用户所在数据库登录(创建用户的数据库)，包括管理员账号。
	管理员可以管理所有数据库，但是不能直接管理其他数据库，要先认证后才可以。
3 mongodb超级管理员账号的创建
1）以权限认证的方式启动mongodb数据库
sudo mongod -auth
启动之后在启动信息中会有如下信息，说明mongodb以权限认证的方式启动成功
[initandlisten] options: { security: { authorization: "enabled" } }

2）创建超级用户 使用admin数据库(超级管理员 数据库上)
use admin
创建超级用户
db.createUser({"user":"python","pwd":"python","roles":["root"]})
创建成功会显示如下信息
Successfully added user: { "user" : "python", "roles" : [ "root" ] }

、
3) 退出客户端再次登录验证 此时再使用数据库各命令的时候会报权限错误，需要认证才能执行相应操作

use admin
db.auth('python','python')
1

python用户是创建在admin数据库上的所以必须来到admin数据库上进行认证,认证成功会返回1，失败返回0

4创建普通用户

1)选择需要创建用户的数据库
use test1
2)在使用的数据库上创建普通用户

db.createUser("user":"user1", "pwd":"pwd1", roles:["read"])
创建普通用户user1,该用户在test1上的权限是只读
db.createUser("user":"user1", "pwd":"pwd1", roles:["readWrite"])
创建普通用户user1,该用户在test1上的权限是读写

3)在其他数据库上创建普通用户
use admin
db.createUser({"user":"python1", "pwd":"python1", roles:[{"role":"read","db":"dbname1"},{"role":"readWrite","db":"dbname2"}
]})


在admin上创建python1用户，python1用户的权限有两个，一个再dbname1上的只读，另一个是在dbname2上的读写

5 查看创建的用户

show users
{
    "_id" : "admin.python",
    "user" : "python",
    "db" : "admin",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}

6 删除用户

db.dropUser('python')

理解MongoDB中的一些概念

之前学习MySQL时，我们知道有

数据库
数据表
记录
字段
学习MongoDB时，有些变化

数据库
集合（对应MySQL中的数据表）
文档（对应MySQL中的记录）
域（对应MySQL中的字段）

MongoDB数据库相关命令

1.查看所有的数据库
show dbs   或者show databases
2. 查看当前正在使用的数据库
db
注意：没有切换数据库的情况下默认使用test数据库
3. 切换数据库
 use 数据库名字
4.创建数据库
use 数据库名字

注意：
如果数据库不存在，则创建数据库，否则切换到指定数据库
刚创建的数据库并不在数据库的列表中，如 要显示它，需要向数据库中插入一些数据，才会看到刚刚创建的数据库（即如果创建了数据库没有数据，show dbs看不到）
MongoDB 中默认的数据库为 test，如果你没有创建新的数据库，集合将存放在 test 数据库中

#5. 删除当前的数据库
db.dropDatabase()


MongoDB集合相关命令
1）查看当前数据库中所有的集合：
	show collections
2)创建集合

2.1 自动创建集合：
	向不存在的集合中第1次加⼊数据时， 集合会被创建出来

2.2 手动创建集合：
db.createCollection(name,options)

demo：db.createCollection("stu")
demo2：db.createCollection("sub", { capped : true, size : 10 } )

说明：

	参数capped： 默认值为false表示不设置上限,值为true表示设置上限
	参数size： 当capped值为true时， 需要指定此参数， 表示上限⼤⼩,当⽂档达到上限时， 会将之前的数据覆盖， 单位为字节
	检查集合是否有上限: db.集合名.isCapped()

3)删除集合：

db.集合名称.drop()

4）查看集合中的数据

db.集合名.find()
demo:
db.tea.find()

5)db.集合名.insert({name:"",age:"",…})

db.tea.insert({name:"wp2",age:28})

MongoDB中常见的数据类型

常见类型

Object ID： ⽂档ID
String： 字符串， 最常⽤， 必须是有效的UTF-8
Boolean： 存储⼀个布尔值， true或false
Integer： 整数可以是32位或64位， 这取决于服务器
Double： 存储浮点值
Arrays： 数组或列表， 多个值存储到⼀个键
Object： ⽤于嵌⼊式的⽂档， 即⼀个值为⼀个⽂档
Null： 存储Null值
Timestamp： 时间戳， 表示从1970-1-1到现在的总秒数
Date： 存储当前⽇期或时间的UNIX时间格式

#注意点
每个⽂档都有⼀个属性， 为_id， 保证每个⽂档的唯⼀性，mongodb默认使用_id作为主键
可以⾃⼰去设置_id插⼊⽂档，如果没有提供， 那么MongoDB为每个⽂档提供了⼀个独特的_id， 类型为objectID
objectID是⼀个12字节的⼗六进制数,每个字节两位，一共是24 位的字符串： 前4个字节为当前时间戳 接下来3个字节的机器ID 接下来的2个字节中MongoDB的服务进程id 最后3个字节是简单的增量值

MongoDB的增删改查

文档的数据结构和 JSON 基本一样。

所有存储在集合中的数据都是 BSON 格式。BSON 是一种类似 JSON 的二进制形式的存储格式，是 Binary JSON 的简称。
1. MongoDB的插入
	1)insert()方式
	
	MongoDB 使用insert()或 save()方法向集合中插入文档，语法如下：
	db.集合名称.insert(document)
	
	demo：
	db.stu.insert({name:'gj',gender:1})
	db.stu.insert({_id:"20170101",name:'gj',gender:1})
	
	插⼊⽂档时， 如果不指定_id参数， MongoDB会为⽂档分配⼀个唯⼀的ObjectId

	2)save()方式
	命令：
	db.集合名称.save(document)
	如果⽂档的_id已经存在则修改， 如果⽂档的_id不存在则添加



2.MongoDB的简单查询

命令：
	db.集合名称.find()
	
	如果需要以易读的方式来读取数据，可以使用 pretty()方法，语法格式如下：
	db.集合名称.find().pretty()
	
3.MongoDB的更新
	命令：
	db.集合名称.update(<query> ,<update>,{multi: <boolean>})

	
	参数query:查询条件
	参数update:更新操作符
	参数multi:可选， 默认是false，表示只更新找到的第⼀条记录， 值为true表示把满⾜条件的⽂档全部更新

	demo：查询到的第1条用新的文档进行覆盖
	db.stu.update({name:'hr'},{name:'mnc'})

	demo：指定键值更新操作	
	db.stu.update({name:'hr'},{$set:{name:'hys'}})
	
	demo：更新全部
	db.stu.update({},{$set:{gender:0}},{multi:true})



4.MongoDB的删除

命令：
db.集合名称.remove(<query>,{justOne: <boolean>})
说明：
参数query:可选，删除的⽂档的条件
参数justOne:可选， 如果设为true或1， 则只删除⼀条， 默认false， 表示删除多条

查询进阶

1. 数据查询

	⽅法find()： 查询
	
	db.集合名称.find({条件⽂档})
	
	⽅法findOne()：查询，只返回第⼀个
	
	db.集合名称.findOne({条件⽂档})
	
	⽅法pretty()： 将结果格式化
	
	db.集合名称.find({条件⽂档}).pretty()
	


2.插入多个数据insertMany

db.stu.insertMany([{"name" : "郭靖", "hometown" : "蒙古", "age" : 20, "gender" : true },{"name" : "⻩蓉", "hometown" : "桃花岛", "age" : 18, "gender" : false },{"name" : "华筝", "hometown" : "蒙古", "age" : 18, "gender" : false },{"name" : "⻩药师", "hometown" : "桃花岛", "age" : 40, "gender" : true },{"name" : "段誉", "hometown" : "⼤理", "age" : 16, "gender" : true },{"name" : "段王爷", "hometown" : "⼤理", "age" : 45, "gender" : true },{"name" : "洪七公", "hometown" : "华⼭", "age" : 18, "gender" : true }])

3.比较运算符

等于： 默认是等于判断， 没有运算符
⼩于：$lt （less than）
⼩于等于：$lte （less than equal）
⼤于：$gt （greater than）
⼤于等于：$gte
不等于：$ne


查询年龄大于或者等于18的所有学生
db.stu.find({age:{$gte:18}})

4.逻辑运算符

逻辑运算符主要指与、或逻辑

and：在json中写多个条件即可

查询年龄⼤于或等于18， 并且性别为true的学⽣
db.stu.find({age:{$gte:18},gender:true})

or:使⽤$or， 值为数组， 数组中每个元素为json
db.stu.find({$or:[{age:{$gt:18}},{gender:false}]})

查询年龄⼤于18或性别为男⽣， 并且姓名是郭靖
db.stu.find({$or:[{age:{$gt:18}},{gender:true}], name:"郭靖"}).pretty()

5.范围运算符

查询年龄为18、 28的学⽣
db.stu.find({age:{$in:[18,28]}})


使⽤$in， $nin 判断数据是否在某个数组内
查询年龄为18、 28的学⽣
db.stu.find({age:{$in:[18,28]}})

6.⽀持正则表达式

使⽤//或$regex编写正则表达式

查询以“段”开始的姓名
方式1：
db.Test.find({name:/^段/}).pretty()
方式2：
db.Test.find({name:{$regex:"^段"}}).pretty()



运行结果

{
	"_id" : ObjectId("5d22b9f846f899bfae92453d"),
	"name" : "段誉",
	"hometown" : "⼤理",
	"age" : 16,
	"gender" : true
}
{
	"_id" : ObjectId("5d22b9f846f899bfae92453e"),
	"name" : "段王爷",
	"hometown" : "⼤理",
	"age" : 45,
	"gender" : true
}

7.自定义查询*

由于mongo的shell是一个js的执行环境 使⽤$where后⾯写⼀个函数， 返回满⾜条件的数据

查询年龄⼤于30的学⽣

db.stu.find({
    $where:function() {
    #this指向集合stu中的每一个元素
        return this.age>30;
    }
})


demo：

db.stu.find({
$where:function(){
return this.age*10>200||this.gender == false}
})

进阶用法

高级用法

1.limit
	limit()： ⽤于读取指定数量的⽂档
	用法：
	db.集合名称.find().limit(NUMBER)
	
	查询2条学⽣信息：
	db.stu.find().limit(2)

2.skip
	skip:⽤于跳过指定数量的⽂档
	用法：
	db.集合名称.find().skip(NUMBER)
	
	跳过前2个，从第3个开始查询：
	db.stu.find().skip(2)

3. 同时使用limit和skip
	db.stu.find().limit(4).skip(5)
	或
	db.stu.find().skip(5).limit(4)
	**注意：先使用skip在使用limit的效率要高于前者**

4.投影
	在查询到的返回结果中， 只选择必要的字段
	命令：
	db.集合名称.find({},{field:1,...})
	说明：

	参数为字段和值， 值为1表示显示， 值为0不显

	**特别注意： 对于_id列默认是显示的， 如果不显示需要明确设置为0**
	demo：
	db.stu.find({},{_id:0,name:1,gender:1})



5.排序
⽅法sort()， ⽤于对结果集进⾏排序

命令：
db.集合名称.find().sort({字段:1,...})
说明：

参数1为升序排列 参数-1为降序排列
demo:根据性别降序， 再根据年龄升序

db.stu.find().sort({gender:-1,age:1})


6.统计个数
⽅法count()⽤于统计结果集中⽂档条数

命令方式1：
db.集合名称.find({条件}).count()
命令方式2：
db.集合名称.count({条件})


demo：
 db.stu.find({gender:true}).count()
 db.stu.count({age:{$gt:20},gender:true})

7.消除重复

⽅法distinct()对数据进⾏去重
命令：
db.集合名称.distinct('去重字段',{条件})

demo：年龄大于18岁的所有不重复的hometown
db.stu.distinct('hometown',{age:{$gt:18}})

聚合操作

1.MongoDB的聚合是什么
聚合(aggregate)是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果。

语法：
db.集合名称.aggregate({管道:{表达式}})


2.常用管道和表达式
	2.1 常用管道命令
		在MongoDB中，⽂档处理完毕后， 通过管道进⾏下⼀次处理 常用管道命令如下：
		$group： 将集合中的⽂档分组， 可⽤于统计结果
		$match： 过滤数据， 只输出符合条件的⽂档
		$project： 修改输⼊⽂档的结构， 如重命名、 增加、 删除字段、 创建计算结果
		$sort： 将输⼊⽂档排序后输出
		$limit： 限制聚合管道返回的⽂档数
		$skip： 跳过指定数量的⽂档， 并返回余下的⽂档
	2.2 常用表达式
	语法：表达式:'$列名' 常⽤表达式:
		$sum： 计算总和， $sum:1 表示以1倍计数
		$avg： 计算平均值
		$min： 获取最⼩值
		$max： 获取最⼤值
		$push： 在结果⽂档中插⼊值到⼀个数组中
		#3 管道命令之$group

3 管道命令之$group
	#3.1 按照某个字段进行分组
	
	$group是所有聚合命令中用的最多的一个命令，用来将集合中的文档分组，可用于统计结果
	使用示例如下

	db.stu.aggregate(
	    {$group:
	        {
	            _id:"$gender",
	            count:{$sum:1}
	        }
	    }
	)

其中注意点：
db.db_name.aggregate是语法，所有的管道命令都需要写在其中
_id 表示分组的依据，按照哪个字段进行分组，需要使用$gender表示选择这个字段进行分组
$sum:1 表示把每条数据作为1进行统计，统计的是该分组下面数据的条数



3.2 group by null

当我们需要统计整个文档的时候，$group 的另一种用途就是把整个文档分为一组进行统计
使用实例如下：


db.stu.aggregate(
    {$group:
        {
            _id:null,
            counter:{$sum:1}
        }
    }
)


其中注意点：
_id:null 表示不指定分组的字段，即统计整个文档，此时获取的counter表示整个文档的个数


3.3 数据透视
正常情况在统计的不同性别的数据的时候，需要知道所有的name，需要逐条观察，如果通过某种方式把所有的name放到一起，那么此时就可以理解为数据透视

使用示例如下：
1）统计不同性别的学生

	 db.stu.aggregate(
     {$group:
         {
             _id:null,
             name:{$push:"$name"}
         }
     }
 )
			
2）使用$$ROOT可以将整个文档放入数组中	
	
	db.stu.aggregate(
     {$group:
         {
             _id:null,
             name:{$push:"$$ROOT"}
         }
     }
 )			

4 管道命令之$match

$match用于进行数据的过滤，是在能够在聚合操作中使用的命令，和find区别在于$match 操作可以把结果交给下一个管道处理，而find不行

使用示例如下：
查询年龄大于20的学生

		 db.stu.aggregate(
	     {$match:{age:{$gt:20}}
	     )

查询年龄大于20的男女学生的人数

 db.stu.aggregate(
     {$match:{age:{$gt:20}}
     {$group:{_id:"$gender",counter:{$sum:1}}}
     )




5 管道命令之$project
$project用于修改文档的输入输出结构，例如重命名，增加，删除字段

使用示例如下：

查询学生的年龄、姓名，仅输出年龄姓名

 db.stu.aggregate(
     {$project:{_id:0,name:1,age:1}}
     )


查询男女生的人数

 db.stu.aggregate(
     {$group:{_id:"$gender",counter:{$sum:1}}}
     {$project:{_id:0,counter:1}}
     )



6 管道命令之$sort
$sort用于将输入的文档排序后输出

使用示例如下：

	1）查询学生信息，按照年龄升序
	 db.stu.aggregate({$sort:{age:1}})

	2）查询男女人数，按照人数降序

	 db.stu.aggregate(
	     {$group:{_id:"$gender",counter:{$sum:1}}},
	     {$sort:{counter:-1}}
	 )


7 管道命令之$skip 和 $limit
	$limit限制返回数据的条数
	$skip 跳过指定的文档数，并返回剩下的文档数
	同时使用时先使用skip在使用limit

使用示例如下：

	1）查询2条学生信息
	
	 db.stu.aggregate(
	     {$limit:2}
	 )
	 
	 2）查询从第3条开始的学生信息

	 db.stu.aggregate(
	     {$skip:2}
	 )

3）统计男女生人数，按照人数升序，返回第二条数据

 db.stu.aggregate(
     {$group:{_id:"$gender",counter:{$sum:1}}},
     {$sort:{counter:1}},
     {$skip:1},
     {$limit:1}
 )

索引

1.为什么要在MongoDB中创建索引
当数据库中有大量的数据时，为了加快查询速度，我们需要创建索引

2. 创建索引的方法
语法：

db.集合.ensureIndex({属性:1})，1表示升序， -1表示降序
db.集合.createIndex({属性:1})

上面两个命令效果等价
具体操作：
db.db_name.createIndex({name:1})

3. 索引的查看
默认情况下_id是集合的索引
查看方式：db.collection_name.getIndexes()

4.删除索引
语法：db.t1.dropIndex({'索引名称':1})
举例：b.test2000.dropIndex({age:1})

5.MongoDB创建唯一索引
在默认情况下MongoDB的索引域的值是可以相同的,创建唯一索引之后，数据库会在插入数据的时候检查创建索引域的值是否存在，如果存在则不会插入该条数据，但是创建索引仅仅能够提高查询速度,同时降低数据库的插入速度。

db.collection_name.ensureIndex({"name":1},{"unique":true})
db.test2000.createIndex({age:1},{unique:true})
6. 建立复合索引
抓全贴吧信息时，如果把帖子的名字作为唯一索引对数据进行去重是不可取的，因为可能有很多帖子名字相同。	
此时可能用多个域来保证数据的唯一性，这个时候可以考虑建立复合索引来实现。
建立复合索引的语法：

db.collection_name.ensureIndex({字段1:1,字段2:1})
举例：
db.test2000.createIndex({name:1,age:1})


7.建立索引注意点
根据需要选择是否需要建立唯一索引

数据量巨大并且数据库的读出操作非常频繁的时候才需要创建索引，如果写入操作非常频繁，创建索	引会影响写入速度

索引字段是升序还是降序在单个索引的情况下不影响查询效率，但是在复合索引的条件下会有影响

在进行查询的时候如果字段1需要升序的方式排序输出，字段2需要降序的方式排序输出，那么此时复合索引的建立需要把字段1设置为1，字段2设置为-1

MongoDB的备份恢复与导出导入

以下命令是在终端中输入，而不是在mongo客户端中输入

1.备份
保证数据库安全，主要用于灾难处理
备份的语法：mongodump -h dbhost -d dbname -o dbdirectory、

	-h： 服务器地址， 也可以指定端⼝号
	-d： 需要备份的数据库名称
	-o： 备份的数据存放位置， 此⽬录中存放着备份出来的数据
	
	例：mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1bak

2 恢复
恢复语法：mongorestore -h dbhost -d dbname --dir dbdirectory

	-h： 服务器地址
	-d： 需要恢复的数据库实例
	--dir： 备份数据所在位置
	
示例：mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1bak/test1

MongoDB和Python交互

1.pymongo 提供了MongoDB和python交互的所有方法

	安装方式:
	pip install pymongo
	
	MongoDB和Python交互的模块
	pymongo 提供了MongoDB和python交互的所有方法



2.使用pymongo
	2.1 导入pymongo并选择要操作的集合
	数据库和集合如果没有会自动创建
	from pymongo import MongoClient
	client = MongoClient(host,port)
	collection = client[db名][集合名]
	
	2.2 添加数据
	insert可以批量的插入数据列表，也可以插入一条数据
	#插入一条数据
	collection.insert({"name": "test10010", "age": 33})
	#插入多条数据
	collection.insert([{"name": "test10010", "age": 33}, {"name": "test10011", "age": 34}])

	2.3 添加一条数据
	#插入一条数据
	ret = collection.insert_one({"name": "test10010", "age": 33})
	print(ret)
			
	2.4. 添加多条数据
	#插入多条数据
	item_list = [{"name": "test1000%d" % i} for i in range(10)]
	
	#insert_many接收一个列表，列表中为所有需要插入的字典
	t = collection.insert_many(item_list)

	2.5 查找一条数据
	# find_one查找并且返回一个结果,接收一个字典形式的条件
	t = collection.find_one({"name": "test10005"})
	print(t)
	print(type(t))
		
	2.6 查找全部数据
	结果是一个Cursor游标对象，是一个可迭代对象，可以类似读文件的指针
	
	#根据查询条件返回所有满足条件的结果
	#t = collection.find({"name": "test10005"})
	#find返回所有满足条件的结果，如果条件为空，则返回数据库的所有
	t = collection.find()
	#结果是一个Cursor游标对象，是一个可迭代对象，可以类似读文件的指针，
	for i in t:
	    print(i)
	    
	print("-" * 30)
	
	for i in t:  # 此时t中没有内容
	    print(i)




	2.7 更新一条数据
	注意使用$set命令
	# update_one更新一条数据
	collection.update_one({"name": "test10005"}, {"$set": {"name": "new_test10005"}})


	2.8 更新全部数据
	# update_one更新全部数据
	collection.update_many({"name": "test10005"}, {"$set": {"name": "new_test10005"}})



	2.9 删除一条数据
	#delete_one删除一条数据
	collection.delete_one({"name": "test10010"})




	2.10 删除全部数据
	# delete_may删除所有满足条件的数据
	collection.delete_many({"name": "test10010"})