经验拾忆（纯手工）=> MongoDB与PyMongo语法对比解析

摘要：举个栗子你有一个箱子，里面有一个儿子级别和孙子级别的箱子共层现在你把孙子级别的箱子多带带拿出来，把整个箱子替换掉就是这种思想。。。自己体会吧这种语法，好像列表的切片赋值。。官方建议我们用它的好处是把和由两个函数调用变为个参数传进去了。

由于是对比书写:
    M: 代表 Mongo原生语法
    P: 代表 PyMongo书写方法
    
    后面提到：”同上“ 字眼：
        意思就是 Mongo 和 PyMongo 语句是一模一样的， 一个字都不差，复制上去，可以直接运行
        （也许你很好奇，为什么 一个是Python语言里的PyMongo，一个是Mongo）
        他们的语句为什么可以做到一模一样 ？？
        答：因为 Mongo和Python都可以 给变量赋值， PyMongo的语法设计也是模仿Mongo的。
            所以：我巧妙的 把二者的变量设为同一个，函数90%都一致， 所以整条语句就一模一样了！
    
    主要语法区别：
        1. 函数命名
            Mongo  方法函数大都以 驼峰命名
            PyMongo方法函数大都以 _ 下划线分割命名
        2. 函数参数
            Mongo :  基本都是 {} + [] 各组组合格式 
            PyMongo：同上， 但{}的 key需要使用字符串格式， 有些情况，还需要使用命名参数代替 {}
        3. 空值 与 Bool
            Mongo: null  true false
            PyMongo: None True False

        

客户端连接：

 pip install pymongo
 import pymongo
    
 M: Mongo
 P: cursor = pymongo.MongoClient("ip",port=27017) 

选择数据库：

 M: use test
 P: db = cursor["test"]       # 记住这个db，  下面复用这个参数

选择集合： (记住table变量名，下面就直接用他们了) 注意，注意，注意

 M: table = db.zhang                         
 P: table = db["zhang"]  

 注：选择库，选择集合的时候 注意事项：
 Mongo中：  xx.xx  用 . 的语法
 PyMongo中：也可以 用 xx.xx 这样,  但是这样用在PyCharm中没有语法提示
 
 所以提倡     xx["xx"]      用索引的方式使用

Mongo 与 PyMongo 返回结果的游标比较

 Mongo中：
     大多数查询等结果返回都是游标对象
     如果不对游标遍历，那么Mongo的游标会默认为你取出 前 20 个 值
     当然，你也可以索引取值
     关闭操作： .close()                   
 PyMongo中：
     同样，大多数查询等结果返回都是游标对象（如果你学过ORM，可以理解游标就像 ORM的查询集）
     所以必须通过 list() 或 遍历 或 索引 等操作才能真正取出值
     关闭操作： .close()  或者 用 Python 的 with 上下文协议

save()

M: table.save({})    # 估计要废弃了
P: 将要被废弃 用insert_one代替它

insert()

M: table.insert()         # 包括上面两种，可以一个 {}，可以多个 [{},{}]
P: PyMongo源码明确说明，insert()语法将被废弃，请用 insert_one({}) 和 insert_many([])代替

insert_one() 和 insert_many()

M: 
   table.insertOne( {} )            # 驼峰
   table.insertMany([ {},{} ])      # 驼峰
P:
   table.insert_one( {} )           # 下划线
   table.insert_many([ {},{} ])     # 下划线

remove()

参数1：删除查询条件
参数2：删除选项
M: table.remove({"name":"zhangsan"}, {"justOne": true})   # 我更喜欢用delete的
P: PyMongo中,此方法将被废弃。 将会被 delete_one() 和 delete_many() 代替

deleteOne() # 只删除一条

M: table.deleteOne({"name": "lin3"})
P: table.delete_one({"name": "lin3"})    # 

deleteMany() # 删除多条

M: table.deleteMany({"name": "lin3"})
P: table.delete_many({"name": "lin3"})

注意：
    不知道这两个函数是否让你想起了前面讲的  insertOne 和 insertMany，他们看起来很像，语法不同：
        insertMany([]) # 参数需要用   [] 包起来
        deleteMany({}) # 参数不需要
注意2：
    table.deleteMany({})    # 空 {}， 代表删除所有文档 （慎行，慎行，慎行）

删除整个集合：

table.drop()    # 删除集合（连同 所有文档， 连同 索引，全部删除）

"""
    文档修改,  注意： _id 不可修改
"""

三种更新方法：

1. update(将要废弃，可跳过，直接看2，3点的方法)
   update({查询条件},  {更新操作符} , {更新选项})
   
   M: table.update({"name": {"$regex":"li"}},{"$set":{"name":"lin2"}}, {multi: true})
   P: table.update({"name": {"$regex": "li"}}, {"$set": {"name": "lin3"}},multi=True)
   
   注意1: 第三个参数 multi如果不设置，默认只更新一条文档，设置为 true ，就会更新多条文档
   注意2：
       Mongo写法： {multi: true}        # Mongo 和往常一样，采用json格式， true小写
       Python写法： multi = True        # python是采用命名参数来传递， True大写
       
2. updateOne(更新一条) 
       M: updateOne( {查询条件},  {更新操作符} )   
       P: update_one
3. updateMany(更新多条)
       M: updateMany( {查询条件},  {更新操作符} )     其实参数是一模一样的，只不过方法名区分
       P: update_many
       
       
 注： 这三个方法的参数 是基本一模一样的
      所以下面讲具体  {查询条件},  {更新操作符} 时
      就统一用 update()来写了

普通更新操作符：

$set(更新)

# 注：规则就是："有则改之， 无则添加"
M: table.update({"5":5},{"$set": {"lin": [5,6,7,8]} })
P: 同上

微扩展(关于内嵌数组)：
    table.update({"5":5},{"$set": {"lin.0": "呵呵" })  # lin.0代表数组的第一个元素
    当数组的索引越界，这个时候就视为数组的添加操作。 
    eg: 假定我们给 lin.10 一个值，那么 中间空出的那么多索引，会自动填充 null    
       

$unset(删除)

# 注：删除的键对应的value可以随便写，写啥都会删除， 写 "" 只是为了语义明确（规范）
M: table.update({"6":6}, {"$unset": {"6":""}})     # 把此条记录的 "6" 字段删除
P: 同上
   
微扩展(关于嵌套数组)：
    table.update({"5":5}, {"$unset": {"lin.0":""}}) # lin.0同样代表数组第一个元素
    注：数组的删除 并不是真正的删除， 而是把值 用 null 替换
       

$rename(改名，替换)

M: table.update({"name":"lin"}, {"$rename":{"name":"nick"}})  # name变成了nick
P: 同上
微扩展（文档嵌套）：
    如果文档是嵌套的 eg:   { a: {b:c} } 
        M: table.update({"lin":"lin"}, {"$rename": {"a.b":"d"}})
        P: 同上
        结果 => {"a" : {  }, "d" : "c" }
    解析：
        b   属于 子文档
        a.b 表示 通过父文档的a 来取出 子文档的b
        如果整体a.b被 rename为 d，那么 d会被安排到父文档的层级里，而a设为空。
        举个栗子：
            你有一个箱子，里面 有一个 儿子级别 和 孙子级别 的箱子 （共3层）
            现在你把 孙子级别的箱子 多带带拿出来， 把整个箱子替换掉
            就是这种思想。。。自己体会吧   
                         
           （这种语法，好像Python列表的切片赋值。。形容可能不太恰当）
           

$inc：

{$inc: { "age": -2}}    # 减少两岁，正数表示加法，负数表示减法，简单，不举例了
特例：如果字段不存在，那么，此字段会被添加， 并且值就是你设定的值(0+n=n)

$mul:

{$mul: { "age": 0.5}}   # 年龄除以2，整数表示乘法，小数表示除法，简单，不举例了
特例：如果字段不存在，那么，此字段会被添加， 并且值为0 (0*n=0)                    
      

$min

{$min: { "age": 30}}    # 30比原有值小：就替换， 30比原有值大，则不做任何操作

$max

{$max: { "age": 30}}    # 30比原有值大：就替换， 30比原有值小，则不做任何操作
特例：min和max特例相同，即如果字段不存在，那么，此字段会被添加， 并且值就是你设定的值

数组更新操作符：

"""
    单数组:   xx
    内嵌数组: xx.索引
"""

$addToSet（有序，无重复，尾部添加）

原始数据： {"1":1}
   
M: table.update({"1":1}, {"$addToSet":{"lin":[7,8]}})    
P: 同上

结果 => {"1": 1,"lin": [ [7, 8 ] ]}   # [7,8] 整体插入进来， 特别注意这是二级列表
   

$each ( 给[7,8]加个 $each，注意看结果变化 )

M: table.update({"1": 1}, {"$addToSet": {"lin": {"$each":[7, 8]} }})
P: 同上 
结果 => {"1": 1, "lin": [7,8]}  # 7,8多带带插入进来，参考python的 * 解构
       

$push(数据添加， 比$addToSet强大，可任意位置,可重复)

"""
    补充说明: 
        $addToSet:添加数据有重复，会自动去重
        $push    :添加数据有重复，不会去重，而是直接追加
"""
原始数据: {"1":1}
   
M: table.update(
   { "1": 1 },
   {
     "$push": {
       "lin": {
          "$each": [ {"a": 5, "b": 8 }, { "a": 6, "b": 7 }, {"a": 7, "b": 6 } ],
          "$sort": { "a": -1 },
          "$position": 0,
          "$slice": 2
}}})    # 这里为了清晰点，我就把所有括号折叠起来了  
P: 同上

结果 =>   {"1" : 1, "lin" : [ { "a" : 7, "b" : 6 }, { "a" : 6, "b" : 7 } ] }
终极解析：
    1. 添加数组： 先走 $sort => 根据a 逆序排列
    2. 再走 $position,  0表示：索引定位从0开始
    3. 再走 $slice, 2表示： 取2个
    4. 最后走 $each,把数组元素逐个放进另一个数组，说过的，相当于python的 * 解构操作， 

$pop（只能 删除 头或尾 元素）

M: table.update({"a": a}, {"$pop": {"lin": 1}})        # 删除最后一个
P: 同上
   
注1：$pop参数， 1代表最后一个，  -1代表第一个。 这个是值得注意一下的，容易记反
注2：如果全部删没了，那么会剩下空[]， 而不是彻底删除字段
       

$pull (删除 任何位置 的 指定的元素)

M: table.update({"1": 1},{"$pull":{ "lin":[7,8]}})   # 删除数组中[7,8]这个内嵌数组
P: 同上

$pullAll(基本和 $pull 一致)

M: table.update({"1": 1},{"$pullAll":{ "lin":[ [7,8] ]}})   # 同$pull，但多了个 []
P: 同上

注： $pull 和 $pullAll 针对于 内嵌文档 和 内嵌数组 有细小差别， 差别如下：
    内嵌数组： 
        $pull 和 $pullAll 都严格要求内嵌数组的 排列顺序，顺序不一致，则不返回
    内嵌文档:  
        $pullAll : 严格要求内嵌文档的顺序， 顺序不一致，则 不返回
        $pull    : 不要求内嵌文档的循序，   顺序不一致，一样可以返回

"""
    第一个参数的条件是 筛选出 数据的记录（文档）
    第二个参数的条件是 筛选出 数据的记录中的 属性（字段），不配置 就是 默认 取出所有字段
    find({查询条件}, {投影设置}) 
"""

投影解释

哪个字段 设置为 0， 此字段就不会被投影， 而其他字段全部被投影
哪个字段 设置为 1， 此字段就会被多带带投影， 其他字段不投影
{"name": 0, "age": 0}      # 除了 name 和 age  ，其他字段 都 投影
{"name": 1, "age": 1}      # 只投影 name 和 age, 其他字段 不 投影，（_id除外）

注意:所有字段必须满足如下要求：
    一： 你可以不设置，默认都会被投影
    二： 如果你设置了，就必须同为0，或者同为1,不允许0，1 混合设置(_id除外)
    三： _id虽然可以参与混合设置，但是它只可以设为0， 不可以设为1，因为1是它默认的

通俗理解（0和1的设定）：另一种理解思想 ====> 
    设置为1：  就是 加入 白名单 机制
    设置为0，  就是 加入 黑名单 机制
 
注： _id字段是 MongoDB的默认字段，它是会一直被投影的(默认白名单)
    但是，当你强制指定 {"_id": 0}    ，强制把 _id指定为0，他就不会被投影了（变为黑名单）

语法：
    M: queryset = table.find({}, {"name": 0})
    P: 同上

投影-数组切片($slice)

"""针对投影时的value为数组的情况下，对此数组切片，然后再投影"""
数据条件： {"arr1": [5,6,7,8,9] }
整形参数：
    M: queryset = table.find({},{"arr1":{"$slice": 2}})     # 2表示前2个, -2表示后两个
    P: 同上，一模一样，一字不差
    结果: { "arr1": [5,6] }
数组参数： [skip, limit]    
    M: queryset = table.find({},{"arr1":{"$slice": [2,3]}}) # 跳过前2个，取3个
    P: 同上，一模一样，一字不差

    输出结果 =>  { "arr1": {7,8,9] }
 
    注： 这种数组参数，你可以用 skip+limit 方式理解
         也可以用, python的索引+切片方式理解 （skip开始查索引（0开始数）, 然后取limit个）

投影-数组过滤($elemMatch)

"""
 针对投影时 的value为数组的情况下，根据指定条件 对 数组 过滤，然后再投影
 注意这个过滤机制： 从前向后找，遇到一个符合条件的就立刻投影(类似 python正则的 search)
"""
数据条件: {"arr1": [6,7,8,9]}

M: queryset = table.find({}, {"arr1": {"$elemMatch": {"$gt":5}} })
P: 同上

输出结果 => "arr1" : [ 6 ]

解析：（我自己总结的伪流程，可参考理解）
    1. 准备投影
    2. 发现数组，先处理数组，可看到数组中有 elemMatch条件
       elemMatch在投影中定义为： 
       ”你给我一个条件，我把符合条件的 数组每个元素从前向后筛选
        遇到第一个符合条件的就返回, 剩下的都扔掉  （这里的返回你可以理解为 return）
       “
    3. 把 2 步骤 返回的数据 投影

limit()

limit: （只取前n条）
    M: queryset = table.find({"name":"lin"}).limit(n)    # n就是取的条数
    P: 同上

skip()

skip: （跳过n条，从第n+1条开始取）
    M: queryset = table.find({"name":"lin"}).skip(n)    # 从0开始数
    P: 同上
 
    解释一下skip这个参数n：
        假如n等于2 ，就是从第三个（真实个数）开始取   => 你可以借鉴数组索引的思想 a[2]

count()

count: （统计记录数）
    M: count_num = table.find({"name":"lin"}).skip(1).limit(1).count()
    P: count_num = table.count_documents(filter={"name":"lin"}, skip=1, limit=1)
 
    分析：
        find()   -> 查出 3 条数据
        skip(1)  -> 跳过一条，就是从第二条开始取
        limit(1) -> 接着上面的来，从第二条开始取（算本身哦），取一个，实际上取的就是第二条
        count()  -> 3    # 也许你很惊讶，按常理来说，结果应该为 1(看下面)
 
    count(applySkipLimit=false)    # 这是 API原型，这个参数默认为False
        applySkipLimit: 看名字你就知道这函数作用了吧
            默认不写为 False: 不应用(忽略) skip(), limit() 来统计结果 ==> 上例结果为 3
            设为 True：           结合 skip(), limit() 来统计最终结果 ==> 上例结果为 1
 
    注： 对于 count()  ，Mongo 和 PyMongo都有此方法，且用法是一模一样的。
         那为什么上面PyMongo中我却用了 count_documents() 而不是 count()  ?????
         答：
             因为 运行 或者后 戳进PyMongo源码可清晰看见，未来版本 count() API将要废除。
             官方建议我们用  count_documents()
             它的好处是把 skip() 和 limit() 由两个函数调用 变为 2个参数传进去了。

sort()

sort: 排序
M: queryset = table.find({"name":"lin"}).sort({"_id": -1})  # 注意，参数是{} 对象
P: queryset = table.find({"name":"lin"}).sort( "_id", -1 )    # 注意，这是2个参数
    第一个参数，代表 排序依据的字段属性
    第二个参数，代表 升/降  
        1 : 升序      eg: 456
        -1: 降序      eg: 654

特别注意： 3连招顺序（优先级要牢记）  ()
sort -> skip -> limit   （排序 - 定位 - 挑选） 无论你代码什么顺序，它都会这个顺序执行
eg: queryset = table.find({"name": "lin"}).sort("_id", -1).skip(1).limit(1)

也许你会有这样一个疑惑： 为什么 count_documents 没有放进连招里面？
答：
    你仔细想想， 统计个数，和你排不排序有关系吗？  
    没错，一点关系都没有。。。     sort() 和 count() 没有联系

数组操作符

已有数据条件： { name: ["张","李","王"] }

$all: 
   M: queryset = table.find({"name": {"$all": ["张","李"]}})  # 数组值里必须包含 张和李
   P：同上，一模一样，一字不差
$elemMatch：
   M: queryset = table.find({"name": {"$elemMatch": {"$eq":"张"} }}) # 数组值有张 就行
   P: 同上，一模一样，一字不差

正则

M: db.xx.find( {name: { $regex: /^a/, $options:"i" }} )
P: queryset = db.xx.find({"name": {"$regex": "LIN", "$options": "i"}})
PyMongo版的或者这样写->
    import re
    e1 = re.compile(r"LIN", re.I)      # 把Python的正则对象 代替 Mongo语句
    queryset = db.xx.find({"name": {"$regex": re1 }}) 

聚合表达式

字段路径表达式：

   $name    # 具体字段

系统变量表达式：

   $$CURRENT # 表示管道中，当前操作的文档

反转义表达式：

   $literal: "$name"    # 此处 $name 原语法被破坏，现在它只是单纯的字符串

聚合管道

   """
       单个管道，就像 Python中的 map等高阶函数原理， 分而治之。
       只不过，MongoDB善于将管道串联而已。
       .aggregate([ 里面写管道各种操作  ])
   """

$match（管道查询）

   M: queryset = table.aggregate([{"$match": {"name": "zhangsan"}}])
   P: 同上
   

$project(管道投影)

   数据条件 => 
   [
       {"id":"xxx", "name" : "zhangsan", "age" : 15 },
       {"id":"xxx", "name" : "lisi", "age" : 18 },
       {"id":"xxx", "name" : "wangwu", "age" : 16 }
   ]
   M: queryset = table.aggregate([{"$project": {"_id": 0,"new":"5"}}])
   P: 同上
   
   结果 => [{"new": "5"}, {"new": "5"}, {"new": "5"}]
   注："new"是在投影的时候新加的，会被投影。但是加了此新值，除了_id，其他属性默认都不会被投影了

$skip (管道跳过，原理同前面讲过skip() 略)

$limit（管道截取，原理同前面讲过的limit() ）

   M: queryset = table.aggregate([{"$skip": 1},{"$limit":1}])
   P: 同上
   解释：
       一共三条文档， skip跳过了第一条，从第二条开始取，limit取一条，所以最终取的是第二条

$sort (管道排序，同上,不解释)

   M: queryset = table.aggregate([{"$sort":{"age":1}}])
   P: 同上

$unwind（管道展开数组， 相当于 数学的 分配律）

   数据条件 => {"name" : "Tom", "hobby" : [ "sing", "dance" ]}
   
   path小参数:
       M: table.aggregate([{"$unwind":{"path": "$hobby"}}])   # 注意 path是语法关键词
       P: 同上
       结果 => 
           { "_id" : xx, "name" : "Tom", "hobby" : "sing" }
           { "_id" : xx, "name" : "Tom", "hobby" : "dance" }
       形象例子：
           a * [b+c] => a*b + a*c
   
   includeArrayIndex小参数：
       M: queryset = table.aggregate([{"$unwind": {
                   "path":"$hobby", 
                   "includeArrayIndex":"index"    # 展开的同时会新增index字段记录原索引       
           }}])
       P: 同上
       结果 => 
           {"name" : "Tom", "hobby" : "sing", "index" : NumberLong(0) }
           {"name" : "Tom", "hobby" : "dance", "index" : NumberLong(1) }    
           
   注意：
       $unwind 上面有两种特殊情况：
       情况一：
           文档中无 hobby字段   或   hobby字段为 空数组[]
           那么该文档不参与unwind展开操作， 自然就不会显示结果。
           若想让这种文档也参与 unwind展开操作,那么需要追加小参数 
               "preserveNullAndEmptyArrays":true        # 与 path同级书写
           最终结果，这种字段的文档也会被展示出来，并且 index会被赋予一个 null值
       情况二：
           文档中有 hobby字段，但是该字段的值并不是数组
           那么该文档 会 参与 unwind展开操作，并且会显示出来， 同样 index 会被赋予一个 null值

$lookup（使用方式一）

   使用方式（一）：集合关联 ===> 我的理解是，相当于关系型数据库的 多表查询机制

       集合 <=> 表  ，  多表查询 <=> 多集合查询 
           自身集合 与 外集合 根据我们指定的 关联字段 关联后， 如有关联，
           则新字段的值为 [外集合的关联文档， 。。。]， 有几条文档关联，这个数组就会有几条

   废话不多说，先重新创建两个集合：
   db.user.insertOne({"name":"猫", "country": ["China","USA"]})    # 一条
   db.country.insertMany([{"name":"China"}, {"name":"USA"}])      # 两条
   
   table = db.user        # 看好，我赋值了一下，下面直接写table就行了
   
   M: queryset = table.aggregate([{
       "$lookup": {
           "from": "country",           # 需要连接的另外一个集合的名称（外集合）
           "localField": "country",     # （主集合）连接的 依据 字段
           "foreignField": "name",      # （外集合）连接的 依据 字段
           "as": "new_field"            # 最终关联后查询出来的数据，生成新字段，as用来起名
       }
   }])
   P: 同上
   
   结果 => 
   {
       "_id" : ObjectId("5d2a6f4dee909cc7dc316bf1"),
       "name" : "猫",
       "country" : [
           "China",
           "USA"
       ],                  # 这行之前应该不用解释，这就是 user集合本身的数据，没变
       "new_field" : [     # 这行是新加的字段，后面解释
           {
               "_id" : ObjectId("5d2a6fcbee909cc7dc316bf2"),
               "name" : "China"
           },
           {
               "_id" : ObjectId("5d2a6fcbee909cc7dc316bf3"),
               "name" : "USA"
           }
       ]    
   }    
   解释：
       1. new_field是我们新添加的字段
       2. 因为user集合和country集合 我们给出了2个依据关联字段
          并且这两个关联字段 "China" 和 "USA" 的值都相等
          所以最终 user集合的new_field字段中 会添加 两条 country集合的文档 到 [] 中
       3. 如果无关联, 那么   new_field字段中的值  为  空[]
       

$lookup（使用方式二）:

   使用方式二：不做集合的关联，而是直接把（外集合）经过条件筛选，作为新字段放到（主集合）中。
   
   M: queryset = table.aggregate([{
       "$lookup": {
           "from": "country",                # 外集合
           "let": {"coun": "$country"},      # 使（主集合）的变量 可以放在（外集合）使用
           "pipeline": [{                    # 外集合的专属管道，里面只可以用外集合的属性
               "$match": {                   # 因为设置了 let，所以这里面可以用主集合变量
                   "$expr": {                # $expr使得$match里面可以使用 聚合操作
                       "$and": [
                               {"$eq": ["$name", "China"]},   # 注意，这是聚合的 $eq用法
                               {"$eq": ["$$coun",["China", "USA"]]}
                       ]
                   }
               }
           }],
           "as": "new_field"
       }
   }]) 
   P: 同上
   解释：
       把（外集合） pipeline里面按各种条件 查到的文档， 作为（主集合）new_field 的值。
       当然，如果不需要主集合中的属性，可以舍弃 let 字段

$group （分组--统计种类）

   用法1（分组--统计字段种类）
       M: queryset = table.aggregate([{"$group": {"_id": "$name"}}])    # _id是固定写法
       P: 同上
       结果 => [{"_id": "老鼠"}, {"_id": "狗"}, {"_id": "猫"}]
       
   用法2（分组--聚合）
       数据条件：
           { "name" : "猫", "country" : [ "China", "USA" ], "age" : 18 }
           { "name" : "狗", "country" : "Japna" }
           { "name" : "老鼠", "country" : "Korea", "age" : 12 }
           { "name" : "猫", "country" : "Japna" }
   
       M: queryset = table.aggregate([{
           "$group": {
               "_id": "$name",                    # 根据name字段分组
               "type_count": {"$sum": 1},         # 统计每个分类的 个数
               "ageCount": {"$sum": "$age"},      # 统计age字段的 数字和
               "ageAvg": {"$avg": "$age"},        # 统计age字段的 平均值
               "ageMin": {"$min": "$age"},        # 统计age字段的 最小值
               "ageMax": {"$max": "$age"},        # 统计age字段的 最大值
           }
          }])
       p: 同上
       
       结果:
                   {
                       "_id" : "老鼠",
                       "type_count" : 1,
                       "ageCount" : 12,
                       "ageAvg" : 12,
                       "ageMin" : 12,
                       "ageMax" : 12
                   }
                   {
                       "_id" : "狗",
                       "type_count" : 1,
                       "ageCount" : 0,
                       "ageAvg" : null,
                       "ageMin" : null,
                       "ageMax" : null
                   }
                   {
                       "_id" : "猫",
                       "type_count" : 2,
                       "ageCount" : 18,
                       "ageAvg" : 18,
                       "ageMin" : 18,
                       "ageMax" : 18
                   }
       注意：
           若想直接对整个集合的 做统计，而不是分组再统计
           把 _id改为 null即可  { _id: "null" }      
           # (或者随便写一个匹配不到的 字符串或数字都行，分不了组，就自动给你统计整个集合了)

$out (聚合操作后，将结果写入新集合)

   """
       我的理解是重定向 操作， 或者理解为 视图 操作
       写入的集合如果存在，那么会全部覆盖（但保留索引）
       聚合过程遇到错误，那么会自动执行 ’回滚’操作
   """
   M: 
       table.aggregate([
           { "$group": {"_id": "$name"} },
           { "$out": "newCollection" }
       ])
   P: 同上
   最后验证： db.newCollection.find()   ，你就会看到新集合 及其 里面的内容

   聚合管道 ==> 第二个参数
       table.aggregate([之前说的都是这里面的参数],  下面说这个参数)
       
       allowDiskUse: true
           每个聚合管道占用内存需 < 16M， 过大就会出问题
           allowDiskUse设置为true， 会将内存的 写入到临时文件中，减缓内存压力。

           官方文档：write data to the _tmp subdirectory in the dbPath directory
                    Default: /data/db on Linux and macOS, datadb on Windows
           它说： 默认在  dbPath配置变量下的 子目录_tmp下，  dbPath默认为 : /data/db
       
       M:
           queryset = table.aggregate([{
               "$group": {"_id": "$name"}}],
               {"allowDiskUse": true}           
           )
       P:     
           queryset = table.aggregate([{
               "$group": {"_id": "$name"}}],
               allowDiskUse=True,                 # 注意，这里语法稍有不一样
           )
   

创建索引：

单键索引

  M: table.createIndex({"name":1})
  P: table.create_index([("name",-1)])        # -1代表逆序索引，注意是元组
      

联合索引

  索引命中：最左匹配原则  eg  1,2，3  这三个创建联合索引， 可命中索引为：【1,12,123】
  M: table.createIndex( {"name":1}, {}, {} )           # 多个{}
  P: table.create_index([ ("name",-1), (), () ])       # 多个元组
      

多键索引

  多键是针对于数组来讲的，创建单键的字段 指定为 数组字段， 默认就会设置为多键索引

唯一索引 （unique）

  """注意： 如果集合中，不同文档的字段有重复，创建唯一索引的时候会报错"""
  M: table.createIndex({"name":1}, {"unique":true})
  P: table.create_index([("name", 1),("counrty",1)], unique=True)
      

稀疏索引 (sparse)

  eg:
  一个集合中：
      给 name创建 唯一索引
      插入文档1: 有 name字段
      插入文档2: 无 name字段 （MongoDB会在索引库中，把没有的字段的 索引设为 {字段:null}  ）

      再插入文档3, 无name字段  --> 同样也会把索引库中 name设为 null  
          但是就在这个时候，刚要把索引库中的 name字段设为 null的时候。。。
          
          唯一索引告诉你：” 我这里已经有了一个，{ name:null }，请你滚 ”
          然后就无情的给你报错了（重复索引字段）

      那咋整啊， 别急，稀疏索引就是给你办这事的
      
      设置稀疏索引。 MongoDB就不会把  没有的字段 加入到索引库了
      所以，索引库里面就不会自动添加  {字段: null} 
      重新再次插入文档3， 无name字段， 可成功插入，不存在null的重复问题了

      M: table.createIndex({"name":1}, {"unique":true, "sparse":true})
      P: table.create_index([("name", 1),("counrty",1)], unique=True, sparse=True)

查询索引

  M：queryset = table.getIndexes()
  P: queryset = table.list_indexes()

删除索引

  方式1：
      M: table.dropIndex("索引名")     # 索引名可通过 上面查询索引的指令查
      P: table.drop_index("索引名")    
  方式2：
      M: table.dropIndexes()          # 删除全部，_id除外， 想指定删除多个，可用列表列出
      P: table.drop_indexes()

查看索引性能(是否有效)

  table.上面说过的任一函数().explain()           # 链式调用 explain，表示列出此操作的性能
  eg:
      M: queryset = table.explain().find({"name":"猫"})
      P: 同上
  结果中找到：            
      queryPlanner -> winningPlan -> inputStage -> stage   # stage结果对应说明如下
          COLLSCAN    # 未优化，还是搜的整个集合
          IXSCAN      # 索引起到作用
          
  索引对投影的优化：
      queryPlanner -> winningPlan -> stage   # stage结果对应说明如下
          FETCH         # 索引 对投影 未优化
          PROJECTION    # 索引 对投影 起到优化作用
          
  索引对排序的优化：
      同上 stage  最好 不是 sort
      按索引 正序（逆序） 取数据， 这样就有效避免了机械排序的过程