小知识：（列表去掉[]：）
a = ['123','23']
b = ''.join(a)
print(b)
文章目录
一、MongoDB增删改查操作
1. 增加：insert方法
首先要明确一点，MongoDB存储的时文档，文档其实就是json格式的对象。
语法：
db.collectionName（集合名）.insert(document（文档）)
（1）增加单篇文档（一条数据）
- 增加单篇文档
格式：
db.集合名.insert({})
即：
db.collectionName.insert({title:’nice day’})
- 增加单个文档,并指定_id
db.collectionName.insert({_id:8,age:78,name:’lisi’})
（2）增加多个文档（多条数据）
格式：
db.集合名.insert([{},{},{}])
即：
db.collectionName.insert(
[
{time:'friday',study:'mongodb'},
{_id:9,gender:'male',name:'QQ'}
]
)
查看当前文档内的数据
db.集合名.find()
2. 删除：remove
- 语法:
db.collection.remove(查询表达式, 选项)
选项是指 {justOne:true/false},是否只删一行, 默认为false全部删除，为true则删除一行
- 注意：
- 查询表达式依然是个json对象 {age:20}
- 查询表达式匹配的行,将被删掉.
- 如果不写查询表达式,collections中的所有文档将被删掉
查询表达式相当于条件，查到符合表达式的文档进行删除操作
（1）删除符合条件的文档
- 语法：
db.stu.remove({name:"张三"})
（2）删除大于某个值的文档：$gt
- 语法：
db.stu.remove({age:{$gt:500}})
（3）删除小于某个值的数据：$lt
- 语法：
db.stu.remove({age:{$lt:11}})
（4）删除小于等于某个值的数据：$lte
- 语法：
db.stu.remove({age:{$lte:11}})
（5）删除大于等于：$gte
- 语法：
db.stu.remove({age:{$gte:11}})
（6）删除不等于：$ne
- 语法：
db.stu.remove({age:{$ne:12}})
（7）删除文档，只删除一个：{justOne:true}
该选项有两种写法：
- 第一种：直接在查询表达式后面写true
语法：db.stu.remove({"age":10},true)
- 第二种：在查询语句后面加{justOne:true}
语法：db.stu.remove({"age":10},{justOne:true})
注意：删除的一条数据是从上往下找到的第一条文档
3. 更新 update
- 语法：
db.collection.update(查询表达式,新值,选项)
新值：
注意：如果使用下面语句，不是更新数据，而是更新文档。更新就是用新文档替换旧文档。
db.stu.update({name:"one"},{name:"two"})
案例：
总结：所以update操作想要更新文档内容，必须和更新的操作符配合使用。
操作符：（1）$set 修改某列的值
- 语法：
db.stu.update({name:”jj”},{$set:{name:”kk”}})
操作符（2）$unset 删除某个列
- 语法：
db.stu.update({name:”wangwu”},{$unset:{tag:1})
比如删除wangwu的tag，不需要知道他的tag值，直接用1代替，可以认为后面1是固定的
操作符（3）$rename 重命名某个列
注意：重命名的是key
- 语法：
db.stu.update({name:"wangwu"},{$rename:{name:"firstname"}})
意思就是将name这个key名字改为firstname
操作符（4）$inc 增长某个列（可以增长正数也可以增长负数）；自增某个列的键的值
- 语法:
db.stu.update({name:"xiaoming"},{$inc:{age:10}})### age增加10
也可以为负
选项:
Option的作用:{upsert:true/false,multi:true/false}
- upsert:true/false:默认为false，如果为true，不存在则插入，如果存在就更新。
- multi:true/false默认为false，为true时，会更新匹配到的所有数据。
选项符（1）upsert：true/false：默认false，true则不存在插入，存在更新
- 语法：
db.stu.update({age:200},{$set:{name:"xiaohong3",age:103}},{upsert:true})
注意：能匹配到的，匹配第一个符合条件的更新他
注意：匹配不到的，没有的就会插入进来
选项符（2）multi：true/false：默认为false，只修改一行，为true时，会更新所有的数据
- 语法：
db.stu.update({age:12},{$inc:{age:10}},{multi:true})
4. 查找：find
- 语法:
db.collection.find(查询表达式,查询的列);
db.collections.find(表达式,{列1:1,列2:1});
（1）$nin --> not in：查询不在范围内的
db.stu.find({age:{$nin:[1,2,4]}},{_id=0,age=1})
最后面的是规定要显示或者不显示的列
注意：
-
_id：只有在指定=不显示，才会没有，不写_id=0默认显示；
-
其他类，不指定默认不显示
-
0代表不显示，1代表显示
（2）db.stu.find()：查询所有文档
- 查询所有文档的所有内容
db.stu.find()
- 查询所有文档，最后显示gender属性 (_id属性默认总是查出来)
db.stu.find({},{gendre:1})
- 查询所有文档，最后显示gender属性,且不查询_id属性
db.stu.find({},{gender:1, _id:0})
- 查询所有gender属性值为male的文档中的name属性
db.stu.find({gender:’male’},{name:1,_id:0});
（3）all：指数组所有单元匹配，就是指我指定的内容都要有，通过一个list来指定
db.stu.find({hobby:{$all:["aa","bb"]}})
（4）$exists：是否含有默个列
- {exists:1}表示存在指定字段。
db.stu.find({hobby:{$exists:1}})
- $exists:0 ：不存在某个列
db.stu.find({hobby:{$exists:0}})
（5）查询表达式查询多个字段
db.stu.find({name:"李四",age:10}).pretty()
相当于：
pretty()可写可不写
注意： MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，及常规 SQL 的 AND 条件。类似于 WHERE 语句：WHERE by=‘来源’ AND title='题目。
（6）find常用查询方法
- limit() ## 分页，取几行
db.COLLECTION_NAME.find().limit(NUMBER)
- skip() ## 跳过几行
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
db.COLLECTION_NAME.find().skip(NUMBER).limit(NUMBER)
- sort() ## 排序，KEY:1升序；KEY:-1降序
db.COLLECTION_NAME.find().sort({KEY:1})
- count() ## 计数，返回行数
db.mycol.count()
（7）find查询表达式
- {filed:value} ,是指查询field列的值为value的文档
- $lt小于
db.stu.find({age:{$lt:10}},{name:1,age:1}) - $lte小于等于
- $gt 大于
- $gte大于等于
- $ne — != 查询表达式
- {field:{$ne:value}} —作用：查filed列的值 不等于 value 的文档
db.goods.find({cat_id:{$ne:3}},{cat_id:1,goods_id:1,goods_name:1,_id:0}) //查询cat_id不等3的数据 - $nor ## 所有条件都不满足
{$nor:[条件1,条件2]} 是指 所有条件都不满足的文档为真返回 - $and
{$and:[条件1,条件2]} 是指 所有条件都满足，就为真 - $or
{$or:[条件1,条件2]} 是指 条件1和条件2有一个满足，就为真
5. 查询案例
- //主键为32的商品
db.goods.find({goods_id:32},{goods_id:1})
- //不属第3栏目的所有商品($ne)
db.goods.find({cat_id:{$ne:3}},{cat_id:1})
- //本店价格高于3000元的商品{$gt}
db.goods.find({shop_price:{$gt:3000}},{shop_price:1})
- //本店价格低于或等于100元的商品($lte)
db.goods.find({shop_price:{$lte:100}},{shop_price:1})
- //取出第4栏目或第11栏目的商品($in)
db.goods.find({cat_id:{$in:[4,11]}},{goods_name:1})
db.goods.find({$or:[{cat_id:4},{cat_id:11}]},{cat_id:1})
- //取出100<=价格<=500的商品($and)
db.goods.find({$and:[{shop_price:{$gte:100}},{shop_price:{$lte:500}}]},{shop_p
rice:1})
- //取出不属于第3栏目且不属于第11栏目的商品($and $nin和$nor分别实现)
db.goods.find({$and:[{cat_id:{$ne:3}},{cat_id:{$ne:11}}]},{cat_id:1})
db.goods.find({cat_id:{$nin:[3,11]}},{cat_id:1})
db.goods.find({$nor:[{cat_id:3},{cat_id:11}]},{cat_id:1})
- //取出价格大于100且小于300,或者大于4000且小于5000的商品()
db.goods.find({$or:[{$and:[{shop_price:{$gt:100}},{shop_price:{$lt:300}}]},{$and:[{shop_price:{$gt:4000}},{shop_price:{$lt:5000}}]}]},{shop_price:1})
- //取出goods_id%5 == 1, 即,1,6,11,…这样的商品；mod取余，前面除数，后面余数
db.goods.find({goods_id:{$mod:[5,1]}},{goods_id:1});
二、MongoDB 聚合(db.col.aggregate())
MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。
- 语法：
db.COLLECTION_NAME.aggregate(
[
{管道1},
{管道2},
{管道3}，
...
]
)
- 原理： MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理,管道操作是可以重复的。
1. 聚合框架中常用的几个管道操作
（1）$project：
修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
（2）$match：
用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
（3）$limit：
用来限制MongoDB聚合管道返回的文档数。
（4）$skip：
在聚合管道中跳过指定数量的文档，并返回余下的文档。
（5）$group：
将集合中的文档分组，可用于统计结果。
（6）$sort：
将输入文档排序后输出。
2. group中的一些操作表达式
| 表达式 | 描述 |
|---|---|
| $sum | 计算总和 |
| $avg | 计算平均值 |
| $min | 获取集合中所有文档对应值得最小值 |
| $max | |
| 获取集合中所有文档对应值得最大值 | |
| $first | 根据资源文档的排序获取第一个文档数据 |
| $last | 根据资源文档的排序获取最后一个文档数据 |
- 聚合一些操作练习案例：
- 查询每个栏目下的商品数量
db.collection.aggregate( [{$group:{_id:"$cat_id",total:{$sum:1}}}] );
- 查询goods下有多少条商品
db.goods.aggregate([{$group:{_id:null,total:{$sum:1}}}])
- 查询每个栏目下价格大于50元的商品个数
db.goods.aggregate([{$match:{shop_price:{$gt:50}}}, {$group:{_id:"$cat_id",total:{$sum:1}}}])
- 查询每个栏目下的库存量
db.goods.aggregate([{$group:{_id:"$cat_id" , total:{$sum:"$goods_number"}}}])
- 查询每个栏目下 价格大于50元的商品个数 #并筛选出"满足条件的商品个数" 大于等于3的栏目
（1）价格大于50：
{$match:{shop_price:{$gt:50}}}
（2）要想查出个数大于3的栏目，必须先对cat_id进行分组：
{$group:{_id:"$cat_id",total:{$sum:1}}}
（3）最后用match来去除大于3个的栏目
{$match:{total:{$gte:3}}}
db.goods.aggregate([{$match:{shop_price:{$gt:50}}},{$group:{_id:"$cat_id",total:{$sum:1}}} , {$match:{total:{$gte:3}}}])
- 查询每个栏目下的库存量,并按库存量排序
思路：
（1）按栏目的库存量分组（2）排序
{$group:{_id:"$cat_id" , total:{$sum:"$goods_number"}}}
{$sort:{total:1}}
db.goods.aggregate([{$group:{_id:"$cat_id" , total:{$sum:"$goods_number"}}}, {$sort:{total:1}}])
1是正序，-1是逆序
- 查询每个栏目的商品平均价格,并按平均价格由高到低排序
db.goods.aggregate([{$group:{_id:"$cat_id",avg:{$avg:"$shop_price"}}},{$sort:{avg:-1}}])
注意：对一些复杂的语句，要学会拆分成几个简单的步骤，再一步步求出所符合条件的商品
三、游标
1. 游标是什么？
mongo的游标相当于python中的迭代器。通过将查询结构定义给一个变量，这个变量就是游标。通过这个游标，我们可以每次获取一个数据。
2. 游标的声明：
var curor_name = db.bar.find()
3. 游标的操作：
（1）游标操作前的处理
在进行游标操作之前，我们先用js语法插入1000条数据。
注意：MongoDB在底层上时用js来实现的，所以我们可以通过以下代码，在数据库中插入1000条数据。
for (var i=0;i<1000;i++){
db.bar.insert({_id:i+1,title:'hello world'+i,content:'aaa'+i})
}
我们可以看出，上面就是js的for循环代码。所以在MongoDB中可以将js代码和我们的数据库做操作指令一起配合来使用。
如果数据库中很多数据，比如刚刚插入的1000条，我们执行以下命令：
db.bar.find()
作用：他会将所有的数据都查询出来给我们，此时我们考虑是否能让我们在查询的时候，像python中生成器那样，每次给我们返回一个数据。其实在MongoDB中也有类似生成器这样的东东，他叫游标
（2）游标具体操作
- 游标的一些方法hasNext()和next()：
curor.hasNext()//判断游标是否已经取到尽头，|true表示没有到尽头。 curor.next()//取出游标的下一个单元 - 案例：
var mycusor = db.bar.find().limit(5) print(mycusor.next())//会显示是一个bson格式的数据 printjson(mycusor.next())
- 循环打印：
while(mycusor.hasNext()){ printjson(mycusor.next()) }
（3）游标的toArray()方法，方便我们可以看到所有行
print(mycusor.toArray())//看到所有行
print(mycusor.toArray()[2])//看到第二行
注意：不要使用toArray（），原因是会把所有的行立即以对象的形式放在内存中，可以再取出少数几行时，使用此功能。（占用内存，少用）
（4）cursor.forEach(回调函数)
var gettile = function(obj){print(obj.goods_name)}
var cursor = db.goods.find()
cursor.forEach(gettile)
（5）游标在分页中的应用
一般的，我们假设每页N行，当前是page页，就需要跳过（page-1）*N，再取N行，在mysql中，用limit，offset,N来实现，在MongoDB中，用skip(),limit()函数来实现。
var mycusor = db.bar.find().skip(90).limit(10)//跳过90条，取10条。
var mycursor = db.bar.find().skip(9995);
则是查询结果中,跳过前9995行
查询第901页,每页10条
则是 var mytcursor = db.bar.find().skip(9000).limit(10);
四、索引创建
- 索引提高查询速度,降低写入速度,[权衡常用的查询字段,不必在太多列上建索引]（占用内存）
- 在mongodb中,索引可以按字段升序/降序来创建,便于排序
- 默认是用btree来组织索引文件,2.4版本以后,也允许建立hash索引
1. B tree的概念
B 树是为了磁盘或其它存储设备而设计的一种多叉平衡查找树。
区别：
- （1）有n棵子树的结点中含有n个关键字； 而B树是n棵子树有n-1个关键字
- （2）所有的叶子结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大的顺序链接。而B树的叶子节点并没有包括全部需要查找的信息
- （3）所有的非终端结点可以看成是索引部分，结点中仅含有其子树根结点中最大（或最小）关键字。 而B 树的非终节点也包含需要查找的有效信息
而且： - a.B±tree的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B 树更小。
- b.B±tree查询效率更加稳定
（1） B-tree的介绍
B-Tree是为磁盘等外存储设备设计的一种平衡查找树。因此在讲B-Tree之前先了解下磁盘的相关知识。
系统从磁盘读取数据到内存时是以磁盘块（block）为基本单位的，位于同一个磁盘块中的数据会被一次性读取出来，而不是需要什么取什么。
InnoDB存储引擎中有页（Page）的概念，页是其磁盘管理的最小单位。InnoDB存储引擎中默认每个页的大小为16KB，可通过参数innodb_page_size将页的大小设置为4K、8K、16K
而系统一个磁盘块的存储空间往往没有这么大，因此InnoDB每次申请磁盘空间时都会是若干地址连续磁盘块来达到页的大小16KB。InnoDB在把磁盘数据读入到磁盘时会以页为基本单位，在查询数据时如果一个页中的每条数据都能有助于定位数据记录的位置，这将会减少磁盘I/O次数，提高查询效率。
B-Tree结构的数据可以让系统高效的找到数据所在的磁盘块。为了描述B-Tree，首先定义一条记录为一个二元组[key, data] ，key为记录的键值，对应表中的主键值，data为一行记录中除主键外的数据。对于不同的记录，key值互不相同。
一棵m阶的B-Tree有如下特性：
- 每个节点最多有m个孩子。
- 除了根节点和叶子节点外，其它每个节点至少有Ceil(m/2)个孩子。
- 若根节点不是叶子节点，则至少有2个孩子
- 所有叶子节点都在同一层，且不包含其它关键字信息
- 每个非终端节点包含n个关键字信息（P0,P1,…Pn, k1,…kn）
- 关键字的个数n满足：ceil(m/2)-1 <= n <= m-1
- ki(i=1,…n)为关键字，且关键字升序排序。
- Pi(i=1,…n)为指向子树根节点的指针。P(i-1)指向的子树的所有节点关键字均小于ki，但都大于k(i-1)
B-Tree中的每个节点根据实际情况可以包含大量的关键字信息和分支，如下图所示为一个3阶的B-Tree：
每个节点占用一个盘块的磁盘空间，一个节点上有两个升序排序的关键字和三个指向子树根节点的指针，指针存储的是子节点所在磁盘块的地址。两个关键词划分成的三个范围域对应三个指针指向的子树的数据的范围域。以根节点为例，关键字为17和35，P1指针指向的子树的数据范围为小于17，P2指针指向的子树的数据范围为17~35，P3指针指向的子树的数据范围为大于35。
模拟查找关键字29的过程：
根据根节点找到磁盘块1，读入内存。【磁盘I/O操作第1次】
比较关键字29在区间（17,35），找到磁盘块1的指针P2。
根据P2指针找到磁盘块3，读入内存。【磁盘I/O操作第2次】
比较关键字29在区间（26,30），找到磁盘块3的指针P2。
根据P2指针找到磁盘块8，读入内存。【磁盘I/O操作第3次】
在磁盘块8中的关键字列表中找到关键字29。
分析上面过程，发现需要3次磁盘I/O操作，和3次内存查找操作。由于内存中的关键字是一个有序表结构，可以利用二分法查找提高效率。而3次磁盘I/O操作是影响整个B-Tree查找效率的决定因素。B-Tree相对于AVLTree缩减了节点个数，使每次磁盘I/O取到内存的数据都发挥了作用，从而提高了查询效率。
（2）B+tree的介绍
B+Tree是在B-Tree基础上的一种优化，使其更适合实现外存储索引结构，InnoDB存储引擎就是用B+Tree实现其索引结构。
从上一节中的B-Tree结构图中可以看到每个节点中不仅包含数据的key值，还有data值。而每一个页的存储空间是有限的，如果data数据较大时将会导致每个节点（即一个页）能存储的key的数量很小，当存储的数据量很大时同样会导致B-Tree的深度较大，增大查询时的磁盘I/O次数，进而影响查询效率。在B+Tree中，所有数据记录节点都是按照键值大小顺序存放在同一层的叶子节点上，而非叶子节点上只存储key值信息，这样可以大大加大每个节点存储的key值数量，降低B+Tree的高度。
B+Tree相对于B-Tree有几点不同：
- 非叶子节点只存储键值信息。
- 所有叶子节点之间都有一个链指针。
- 数据记录都存放在叶子节点中。
将上一节中的B-Tree优化，由于B+Tree的非叶子节点只存储键值信息，假设每个磁盘块能存储4个键值及指针信息，则变成B+Tree后其结构如下图所示：
通常在B+Tree上有两个头指针，一个指向根节点，另一个指向关键字最小的叶子节点，而且所有叶子节点（即数据节点）之间是一种链式环结构。因此可以对B+Tree进行两种查找运算：一种是对于主键的范围查找和分页查找，另一种是从根节点开始，进行随机查找。
注意：B+tree和B-tree最大的区别就是B+tree的叶子结点可以指向下一个叶子结点，比起B-tree优化更高
2. hash索引
（1）hash索引的介绍
hash索引基于哈希表实现，只有精确匹配索引所有列的查询才有效。Memory引擎默认使用的是此种索引。
存储引擎对所有的索隐列计算出一个哈希码，将哈希码存储在索引中，同时哈希表中保存每个数据行的指针。
这样，对于此种索引查找速度是非常快的。出现哈希值碰撞的话，索引会以链表的形式存放多个记录指针到
同一个哈希条目中。
Hash检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到数据节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。
但是任何事物都有两面性，他的特殊性也带来了很多弊端和限制。
（2）hash索引缺点
-
（1）Hash 索引仅仅能满足"=",“IN"和”<=>"查询，不能使用范围查询。
-
（2）Hash 索引无法被用来避免数据的排序操作。
由于 Hash 索引中存放的是经过 Hash 计算之后的 Hash 值，而且Hash值的大小关系并不一定和 Hash 运算前的键值完全一样，所以数据库无法利用索引的数据来避免任何排序运算； -
（3）Hash 索引不能利用部分索引键查询。
对于组合索引，Hash 索引在计算 Hash 值的时候是组合索引键合并后再一起计算 Hash 值，而不是单独计算 Hash 值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash 索引也无法被利用。 -
（4）Hash 索引在任何时候都不能避免表扫描。
Hash 索引是将索引键通过 Hash 运算之后，将 Hash运算结果的 Hash 值和所对应的行指针信息存放于一个 Hash 表中，由于不同索引键存在相同 Hash 值，所以即使取满足某个 Hash 键值的数据的记录条数，也无法从 Hash 索引中直接完成查询，还是要通过访问表中的实际数据进行相应的比较，并得到相应的结果。 -
（5）Hash 索引遇到大量Hash值相等的情况后性能并不一定就会比B-Tree索引高。
use aaa for (var i=0;i<1000;i++){ db.bar.insert({_id:i+1,title:'hello world'+i,content:'aaa'+i}) } 通过上面方法插入1000条数据 db.bar.explain('executionStats').find({content:'aaa998'})//性能分析
3. 索引常用命令
-
(1)查看当前索引状态：
db.collection.getIndexes() -
(2)创建普通单列索引：
db.collection.ensureIndex({field:1/-1})//1为正序，-1为逆序 -
(3)删除单个索引：
db.collection.dropIndex({field:1/-1}) -
(4)删除所有索引：
db.collection.dropIndexes()
注意： _id所在的列的索引不能删除。 -
(5)创建多列索引：
db.collection.ensureIndex({field1:1/-1，field2:1/-1})
多列索引的使用范围更广，因为一般情况下，我们都是通过多个字段来进行查询数据的，这时候单列索引其实用不到。
两个列一起建立索引其实就是将两个列绑定到一起，来创建索引 -
（6）子文档索引：
子文档查询：- 插入两条带子文档的数据
db.shop. insert({name: 'N0kia' , SPC: {weight: 120 , area: ' taiwan ' } } ) ; db.shop. insert({name: 'sanxing ' , SPC ：{weight: 100 , area: 'hanguo'} - 查询出产地在台湾的手机
db.shop.find({'spc.area':'taiwan'}) - 给子文档加索引：
db.shop.ensureIndex({'spc.area':1})//子文档索引就创建好了
- 插入两条带子文档的数据
-
(7) 唯一索引：{unique:true}
db.collection.ensureIndex({field:1/-1},{unique:true})注意：唯一索引的列不能重复插入
-
（8）创建稀疏索引：{sparse:true}
稀疏索引的特点：如果针对field列做索引，针对不含field的列的文档，将不建立索引，与之相对，普通索引，会把该文档的field列的值认为null，并建立索引。db.collection.ensureIndex({field:1/-1},{sparse:true}) -
（9）hash索引：
db.collection.ensureIndex({field:'hashed'})
2956
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
