MongoDB基础学习

*:first-child {
margin-top: 0 !important;
}

body>*:last-child {
margin-bottom: 0 !important;
}

/* BLOCKS
=============================================================================*/

p, blockquote, ul, ol, dl, table, pre {
margin: 15px 0;
}

/* HEADERS
=============================================================================*/

h1, h2, h3, h4, h5, h6 {
margin: 20px 0 10px;
padding: 0;
font-weight: bold;
-webkit-font-smoothing: antialiased;
}

h1 tt, h1 code, h2 tt, h2 code, h3 tt, h3 code, h4 tt, h4 code, h5 tt, h5 code, h6 tt, h6 code {
font-size: inherit;
}

h1 {
font-size: 28px;
color: #000;
}

h2 {
font-size: 24px;
border-bottom: 1px solid #ccc;
color: #000;
}

h3 {
font-size: 18px;
}

h4 {
font-size: 16px;
}

h5 {
font-size: 14px;
}

h6 {
color: #777;
font-size: 14px;
}

body>h2:first-child, body>h1:first-child, body>h1:first-child+h2, body>h3:first-child, body>h4:first-child, body>h5:first-child, body>h6:first-child {
margin-top: 0;
padding-top: 0;
}

a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
margin-top: 0;
padding-top: 0;
}

h1+p, h2+p, h3+p, h4+p, h5+p, h6+p {
margin-top: 10px;
}

/* LINKS
=============================================================================*/

a {
color: #4183C4;
text-decoration: none;
}

a:hover {
text-decoration: underline;
}

/* LISTS
=============================================================================*/

ul, ol {
padding-left: 30px;
}

ul li > :first-child,
ol li > :first-child,
ul li ul:first-of-type,
ol li ol:first-of-type,
ul li ol:first-of-type,
ol li ul:first-of-type {
margin-top: 0px;
}

ul ul, ul ol, ol ol, ol ul {
margin-bottom: 0;
}

dl {
padding: 0;
}

dl dt {
font-size: 14px;
font-weight: bold;
font-style: italic;
padding: 0;
margin: 15px 0 5px;
}

dl dt:first-child {
padding: 0;
}

dl dt>:first-child {
margin-top: 0px;
}

dl dt>:last-child {
margin-bottom: 0px;
}

dl dd {
margin: 0 0 15px;
padding: 0 15px;
}

dl dd>:first-child {
margin-top: 0px;
}

dl dd>:last-child {
margin-bottom: 0px;
}

/* CODE
=============================================================================*/

pre, code, tt {
font-size: 12px;
font-family: Consolas, "Liberation Mono", Courier, monospace;
}

code, tt {
margin: 0 0px;
padding: 0px 0px;
white-space: nowrap;
border: 1px solid #eaeaea;
background-color: #f8f8f8;
border-radius: 3px;
}

pre>code {
margin: 0;
padding: 0;
white-space: pre;
border: none;
background: transparent;
}

pre {
background-color: #f8f8f8;
border: 1px solid #ccc;
font-size: 13px;
line-height: 19px;
overflow: auto;
padding: 6px 10px;
border-radius: 3px;
}

pre code, pre tt {
background-color: transparent;
border: none;
}

kbd {
-moz-border-bottom-colors: none;
-moz-border-left-colors: none;
-moz-border-right-colors: none;
-moz-border-top-colors: none;
background-color: #DDDDDD;
background-image: linear-gradient(#F1F1F1, #DDDDDD);
background-repeat: repeat-x;
border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD;
border-image: none;
border-radius: 2px 2px 2px 2px;
border-style: solid;
border-width: 1px;
font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
line-height: 10px;
padding: 1px 4px;
}

/* QUOTES
=============================================================================*/

blockquote {
border-left: 4px solid #DDD;
padding: 0 15px;
color: #777;
}

blockquote>:first-child {
margin-top: 0px;
}

blockquote>:last-child {
margin-bottom: 0px;
}

/* HORIZONTAL RULES
=============================================================================*/

hr {
clear: both;
margin: 15px 0;
height: 0px;
overflow: hidden;
border: none;
background: transparent;
border-bottom: 4px solid #ddd;
padding: 0;
}

/* TABLES
=============================================================================*/

table th {
font-weight: bold;
}

table th, table td {
border: 1px solid #ccc;
padding: 6px 13px;
}

table tr {
border-top: 1px solid #ccc;
background-color: #fff;
}

table tr:nth-child(2n) {
background-color: #f8f8f8;
}

/* IMAGES
=============================================================================*/

img {
max-width: 100%
}
-->

MongoDB基础　　2018-12-14

一个基于分布式文件存储的数据库，介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富 MongoDB将数据存储为一个文档，数据结构由键值（key-value)对组成，MongoDB文档类似于JSON对象，字段值可以包含其他文档，数组及文档数组

MongoDB不同平台的安装

点击访问链接

MongoDB概念

由于MongoDB数据库在关系型和非关系型数据库之间，其数据库结构类似关系型数据库

---

SQL术语/概念     MongoDB术语/概念   解释/说明
database          database          数据库
table             collection        数据库表/集合
row               document          数据记录行/文档
column            field             数据字段/域
index                               index   索引
table joins                         表连接,MongoDB不支持
primary key       primary key       主键,MongoDB自动将_id字段设置为主键

---

RDBMS       MongoDB
数据库         数据库
表格           集合
行            文档
列            字段
表联合         嵌入文档
主键           主键 (MongoDB 提供了 key 为 _id

---

连接MongoDB数据库

mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]

1.mongodb://    固定格式，必须制定
2.username:password@    可选，连接到数据库后会参数登录这个数据库
3.host1 必须指定一个host
4.portx 可选指定端口，不填默认27017
5./database 如果指定username:password@，连接并验证登录指定数据库，若不指定，默认打开test数据库
6.?options  连接选项，所有连接选项都是键值对name=value，键值对之间通过&或；隔开

MongoDB数据库查看

mongodb中默认的数据库为test，如果没有创建新的数据库，集合将存放在test数据库中

- use database_name
    - 如果数据库不存在，则创建数据库，否则切换到指定数据库
- show dbs
    - 查看所有数据库
- show tables
    - 查看某数据中的所有集合
- db.数据库名.insert({'key':'value'})
    - 刚创建的数据库并不在数据库列表中，插入数据才显示

MongoDB删除数据库

-db.dropDatabase()
    - 删除当前数据库，默认为test
- db.集合名.drop()
    - 删除数据库中的集合

MongoDB创建/删除 集合（相当于表）

- db.createCollection(name,options) 创建
    - name:要创建的集合名称
    - options：可选参数，指定有关内存大小以及索引
        - capped    布尔
            - 如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。
        - autoindeld    布尔
            - 如为 true，自动在 _id 字段创建索引。默认为 false。
        - size  数值
            - 为固定集合指定一个最大值(字节计)
        - max   数值
            - 指定固定集合包含文档的最大数量
- db.collection.drop()  删除
    - 成功删除选定集合，则drop()方法返回true 否则返回false

MongoDB插入文档

文档的数据结构和json基本一样
所有存储在集合中的数据都是BSON格式
BSON是一种类json的一种二进制形式的存储格式

-mongodb 使用insert()或save()方法向集合中插入文档
    -insert() 当插入数据中 _id在文档中存在则报错
    - save（）  当插入数据中 _id存在则覆盖原来文档
-db.集合名.insert(document)

MongoDB更新/删除文档

-更新文档 db.集合名.update/save()
    -update(
        <query>,    #查询条件
        <update>,   #update的对象和一些更新的操作符（如$,$inc）等，也可以理解为sql update查询内set后面
        {
            upsert:<boolean>,   #可选 如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入
            multi:<boolean>,    #可选 mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
            writeConcern:<document> #可选 抛出异常的级别
        }
        )
    - save(
        document>,  #文档数据
        {
          writeConcern: <document>  可选，抛出异常
        }
        )
- 删除文档  db.集合名.remove()
    在文档删除前先通过find()命令判断执行条件是否正确

    - remove（
            <query>,    #可选 删除文档的条件
            <justOne>   #可选 如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
            writeConcern: <document>    （可选）抛出异常的级别
        ）

MongoDB查询文档

-find       #查询所有
    - db.集合名称.find()
-findone（）  #查询第一个
    - db.集合名称.findone()
-pretty（）   #将结果格式化
    - db.集合名称.find().pretty()

比较运算符

操作	格式	范例	RDBMS中的类似语句
等于	{<key>:<value>}	db.col.find({"by":"菜鸟教程"}).pretty()	where by = '菜鸟教程'
小于	{<key>:{$lt:<value>}}	db.col.find({"likes":{$lt:50}}).pretty()	where likes < 50
小于或等于	{<key>:{$lte:<value>}}	db.col.find({"likes":{$lte:50}}).pretty()	where likes <= 50
大于	{<key>:{$gt:<value>}}	db.col.find({"likes":{$gt:50}}).pretty()	where likes > 50
大于或等于	{<key>:{$gte:<value>}}	db.col.find({"likes":{$gte:50}}).pretty()	where likes >= 50
不等于	{<key>:{$ne:<value>}}	db.col.find({"likes":{$ne:50}}).pretty()	where likes != 50

逻辑运算符

- and
    - db.集合名称.find({key1:value1,key2:value2})
- or
    - db.集合名称.find(
           {
              $or: [
                 {key1: value1}, {key2:value2}
              ]
           }
        ).pretty()

范围运算符

-in
    - db.集合名.find(
            {
                $in:[范围值]
            }

模糊匹配

- / /
    - db.集合名.find(
            {
                <key>:/匹配字段/
            }
        )

正则表达式

-使用 // 或 $regex 编写正则表达式
    -实例：
        db.集合名.find({stu:/^abc/})
        db.集合名.find({stu:{$regex:"^abc"}})
-db.集合名.find(
            {
                <field>:{$regex:"pattern",$options:"<options>"}
            }
        )

    -options可选项：可以组合使用
        -i 忽略大小写
        -m 多行匹配模式
        -x 忽略非转义的空白字符
        -s 单行匹配模式

Limit与skip方法

需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，
limit()方法

-limit()
    - db.集合名.find().limit(number)
    - 接受一个数字参数，该参数指定从MongoDB中读取的记录条数。

- skip()    默认参数为0
    - db.集合名.find().skip(number)
    - 跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。
-两个方法可以组合使用
    - db.集合名.find().skip(num).limit(num)
    或  db.集合名.find().limit(num).skip(num)

MongoDB排序、统计个数、消除重复

-sort()     #排序
    - db.集合名.find().sort({key:1})
        - sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，
        - 其中 1 为升序排列，而 -1 是用于降序排列。
- count()       #统计个数
    - db.集合名.find().count()
    或   db.集合名.count({条件})

- distinct()    #消除重复（对数据去重）
    - db.集合名.distinct(key，{条件})

MongoDB投影

-字符的显示
    -实例：db.stu.find({age:{$gt:18},{name:1,_id:0}})
    - 设置为1显示，_id设置为0不显示

MongoDB索引

索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构

-createIndex（）      #创建索引
    - db.集合名.createIndex(keys,options)
        -  Key 值为你要创建的索引字段（一致多个key），1 为指定按升序创建索引，-1 为指定按降序创建索引

        - ooptions参数参考地址:http://www.runoob.com/mongodb/mongodb-indexing.html
-getIndexts()       #查看当前集合所有索引
    - db.集合名.getIndexs()
- dropIndex()       #删除集合指定索引
    - db.集合名.dropIndex("索引名")
- dropIndexs()      #删除集合所有索引
- totalIndexSize()  #查看集合索引大小
    - db.集合名.totalIndexSize()

MongoDB聚合

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。

- aggregate()
    - db.集合名称.aggregate(aggregate_opeation)

聚合表达式

处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

表达式	描述	实例
$sum	计算总和	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
$avg	计算平均值	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
$min	获取集合中所有文档对应值得最小值	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
$max	获取集合中所有文档对应值得最大值。	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
$push	在结果文档中插入值到一个数组中。 db.mycol.aggregate([{$group :	{_id : "$by_user", url : {$push: "$url"}}}])
$addToSet	在结果文档中插入值到一个数组中，但不创建副本	。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
$first	根据资源文档的排序获取第一个文档数据。	db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
$last	根据资源文档的排序获取最后一个文档数据	db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

管道

1. 管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。
2. MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。

常用管道	作用
$project	修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
$match	用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
$limit	用来限制MongoDB聚合管道返回的文档数。
$skip	在聚合管道中跳过指定数量的文档，并返回余下的文档。
$unwind	将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
$group	将集合中的文档分组，可用于统计结果。
$sort	将输入文档排序后输出。
$geoNear	输出接近某一地理位置的有序文档。

管道实例：以下的例子均无数据作为前提，通过自行脑补

1.$group

将集合中的文档分组，可用于统计结果

- 实例：求学生总人数，平均年龄
    db.stu.aggregate(
        {
             _id:null,  #其分组的依据是 _id:后面的字段
            counter:{$sum:1},
            avgage:{$avg:'$age'}    #需要执行的字段需要添加 $
        }
    )

2.$project

修改输入文档的结构

-实例：在$group 中的输出结果 存在 _id ,可通过$project修改
    db.stu.aggregate(
        {$group:{_id:'$gender',count:{$sum:1},avg_age:{$avg:'$age'}}},
        {$project:{gender:'$_id',count:1,avg_age:1,_id:0}}  #当_id设置为0 ，其字段隐藏
    )

3.$match

用于过滤数据，只输出符合条件的文档,把结果交给下一管道，find()不可以

-实例：选择年龄大于20的学生，观察男性和女性有多少人
    db.stu.aggregate(
            { $match:{ age:{$gt:20} } },
            { $group:{_id:"$gender",count:{$sum:1} } },
            { $project:{ _id:0,gender:"$_id",count:1 } }
        )

4.sort()

将输入文档排序后输出 -实例：查询学生信息，按年龄升序 db.stu.aggregate( { $sort:{age:1} } )

5.limit()

在聚合管道中跳过指定数量的文档，并返回余下的文档

-实例：跳过前两个文档
    db.stu.aggreagate(
        {
            $limit:2
        }
    )

6.unwind()

将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。

-实例1：
    添加实验数据：db.t1.insert({_id:1,item:'t-shirt',size:['S','M','L']})
    执行：
        db.t1.aggregate(
            {$unwind:'$size'}
        )
    结果：
        {"_id":1,"item":"t-shirt","size":"S"},
        {"_id":1,"item":"t-shirt","size":"S"},
        {"_id":1,"item":"t-shirt","size":"S"}
-实例2：保留某字段没有对应拆分的集合,(即保留size为null或为空的文档)
    db.t1.aggregate(
        {
            $unwind:{
                path:'$size',preserveNullAandEmptyArrays:true
            }
        }
    )

MongoDB复制（副本集）和分片

详情请点击此博文

MongoDB复制集

复制的基本架构：由3台服务器组成，一个三成员的复制集，由三个有数据，或者两个有数据，一个作为仲裁者

MongoDB分片

高数据量和吞吐量的数据库应用会对单机的性能造成较大压力,大的查询量会将单机的CPU耗尽,大的数据量对单机的存储压力较大,最终会耗尽系统的内存而将压力转移到磁盘IO上。

解决方案：

垂直扩展：增加更多的CPU和存储资源来扩展容量。

水平扩展：将数据集分布在多个服务器上。水平扩展即分片。

分片集群架构

组件	说明
Config Server	存储集群所有节点、分片数据路由信息。默认需要配置3个Config Server节点。
Mongos	提供对外应用访问，所有操作均通过mongos执行。一般有多个mongos节点。数据迁移和数据自动平衡。
Mongod	存储应用数据记录。一般有多个Mongod节点，达到数据分片目的。

1. mongos ：数据路由，和客户端打交道的模块。mongos本身没有任何数据，他也不知道该怎么处理这数据，去找config server
2. config server：所有存、取数据的方式，所有shard节点的信息，分片功能的一些配置信息。可以理解为真实数据的元数据。
3. shard：真正的数据存储位置，以chunk为单位存数据。

MongoDB备份与恢复

-mongodump -h dbhost -d dbname -o dbdirectory
    -h MongoDB所在服务器地址   例如：127.0.0.1:27017
    -d 需要备份的数据库实例   例如：test
    -o 备份的数据存放位置        例如：c:/data/dump
-mongorestore -h <hostname><:port> -d dbname <path>
    -host<:port>,-h <:port>
        - MongoDB所在服务器地址，默认：localhost:27017
    - db,-d:
        - 需要恢复的数据库实例，例如：test
    - drop:
        - 恢复的时候，先删除当前数据，然后恢复备份数据
    - <path>:
        - mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。
            - 你不能同时指定 <path> 和 --dir 选项，--dir也可以设置备份目录。
    - dir：
        - 指定备份的目录
            - 不能同时指定<path>和 --dir选项