MongoDB——菜鸟教程学习笔记

--创建数据库
use test
--删除数据库
db.dropDatabase()
--查看集合
show dbs
--创建集合
db.createCollection("runoob")
--查看集合
show collections
--创建固定集合mycol，规定该集合空间大小为6142800KB，文档个数最大为10000个
db.createCollection("mycol", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
--MongoDB中可以不创建集合，当插入文档时，会自动创建集合。
--插入集合mycol2
db.mycol2.insert({"name" : "菜鸟教程"})
--删除集合mycol2
db.mycol2.drop()
--mongodb中常见的比较运算符
$eq = (等于)
$gt > (大于)
$gte >= (大于等于)
$lt < (小于)
$lte <= (小于等于)
$ne != (不等于)
$in in (in)
$nin !in (not in)$eq = (等于)
$gt > (大于)
$gte >= (大于等于)
$lt < (小于)
$lte <= (小于等于)
$ne != (不等于)
$in in (in)
$nin !in (not in)

-------------------------------------------------------------------------插入操作-------------------------------------------------------------------------
--通常插入mongodb中的数据
db.col.insert({title: 'MongoDB 教程',
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
--访问插入集合中的数据
db.col.find()
--向指定集合中插入一条文档数据
db.document.insertOne({"a": 3})
--向指定集合中插入多条文档数据
db.res.insertMany([{"b": 3}, {'c': 4}])

-------------------------------------------------------------------------更新操作-------------------------------------------------------------------------
--MongoDB执行update操作的格式
db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)
query : update的查询条件，类似sql update查询内where后面的。
update : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
writeConcern :可选，抛出异常的级别。
--修改第一条数据
--插入数据
db.col.insert({
    title: 'MongoDB 教程',
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
--执行update指令修改遇见的第一条数据
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
--执行update指令修改所有数据
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}},{multi:true})

--save()方法用于将原本集合内的文档替换，但在使用save时，由于mongodb默认是_id为主键，所以需要在实例类中添加一个_id字段，否则则会有重复数据出现。
db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)
--document : 文档数据。
--writeConcern :可选，抛出异常的级别。
--如下例所示：
--更新前：
db.col.find().pretty()
{
        "_id" : ObjectId("56064f89ade2f21f36b03136"),
        "title" : "MongoDB",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "菜鸟教程",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
--更新后：
db.col.save({
    "_id" : ObjectId("56064f89ade2f21f36b03136"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "Runoob",
    "url" : "http://www.runoob.com",
    "tags" : [
            "mongodb",
            "NoSQL"
    ],
    "likes" : 110
})
--在新版本的mongodb中，新增了两个更新操作，一个是updateOne(),另一个是updateMany()。以下面代码为例，分别介绍两个函数
db.test_collection.insert( [
{"name":"abc","age":"25","status":"zxc"},
{"name":"dec","age":"19","status":"qwe"},
{"name":"asd","age":"30","status":"nmn"},
] )
--updateOne()用于更新一条数据，如下例所示
db.test_collection.updateOne({"name":"abc"},{$set:{"age":"28"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
--运行结果为
db.test_collection.find()
{ "_id" : ObjectId("59c8ba673b92ae498a5716af"), "name" : "abc", "age" : "28", "status" : "zxc" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b0"), "name" : "dec", "age" : "19", "status" : "qwe" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b1"), "name" : "asd", "age" : "30", "status" : "nmn" }
--可见当筛选条件为"name"等于"abc"时，该条数据的"abc"值被改变，由原先的25改成28
--而updateMany()则用于批量更新数据，如下例所示：
db.test_collection.updateMany({"age":{$gt:"10"}},{$set:{"status":"xyz"}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
--运行结果为
db.test_collection.find()
{ "_id" : ObjectId("59c8ba673b92ae498a5716af"), "name" : "abc", "age" : "28", "status" : "xyz" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b0"), "name" : "dec", "age" : "19", "status" : "xyz" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b1"), "name" : "asd", "age" : "30", "status" : "xyz" }
--可见当筛选条件为"age":{$gt:"10"}时，符合条件的数据，字段"status"全都更新为"xyz"

-------------------------------------------------------------------------删除操作-------------------------------------------------------------------------
--remove() 方法用于移除数据，基本语法格式如下所示：
db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)
--query :（可选）删除的文档的条件。
--justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
--writeConcern :（可选）抛出异常的级别。
--如下例所示，先执行两遍插入语句，确定向数据库中插入两条相同数据
--需注意，remove()并不会真正释放存储空间，因此需要执行"db.repairDatabase()"，将空间释放
db.col.insert({title: 'MongoDB 教程',
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
--执行remove操作
db.col.remove({'title':'MongoDB 教程'})
--此时数据库中数据被删除，执行"db.col.find()"操作，无数据
--再次插入两条数据，执行删除一条数据的操作
db.col.remove({'title':'MongoDB 教程'},1)
--此时数据库中数据被删除了第一条，仍有数据留在数据库中，如下所示
> db.col.find()
{"_id" : ObjectId("5cce4f860ba0582010d45942"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
  "mongodb",
  "database",
  "NoSQL"
],
"likes" : 100
}
--随着版本更迭，新版本的mongodb官方文档中，推荐使用 deleteOne() 和 deleteMany()来进行删除操作，语法格式如下所示
--删除 status 等于 D 的一个文档
db.inventory.deleteOne( { status: "D" } )
--删除 status 等于 A 的全部文档
db.inventory.deleteMany({ status : "A" })

-------------------------------------------------------------------------查询操作-------------------------------------------------------------------------
--MongoDB 查询数据的语法格式如下：
db.collection.find(query, projection)
--query ：可选，使用查询操作符指定查询条件
--projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值，只需省略该参数即可（默认省略）。
--如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，其中pretty() 方法以格式化的方式来显示所有文档，语法格式如下：
db.col.find().pretty()
--MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规SQL的AND 条件，语法如下所示
db.col.find({key1:value1, key2:value2}).pretty()
--以刚才插入数据为例：
db.col.find({"by":"菜鸟教程", "title":"MongoDB 教程"}).pretty()
--输出结果为
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "菜鸟教程",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
--mongodb中的$or关键字，类似于传统数据库中的OR操作，语法如下所示：
db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()
--仍然以上例进行测试，得出结果如下：
db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "菜鸟教程",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
--需注意，语句"$or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]"，类似于"where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')"
--此外，查询语法范例中用到的"projection"，称之为投影操作符，用法通常有两种，如下所示
--inclusion模式：指定返回的键，赋默认值"1",表示需要返回的键，不返回其他键
db.col.find({likes: {$gt:50}},{url:1,description:1})
--exclusion模式：指定不返回的键，赋默认值"0",表示不需要返回的键，只返回其他键
db.col.find({likes: {$gt:50}},{url:0,description:0})
--需注意的是，以上两种方式不可以混用，否则会报错
--指定查询条件参数 query 可以用 {} 代替，但是需要指定 projection 参数，如下所示
db.col.find({},{url:1,description:1})

-------------------------------------------------------------------------条件操作符-------------------------------------------------------------------------
--条件操作符用于比较两个表达式并从mongoDB集合中获取数据，MongoDB中条件操作符有：
(>) 大于 - $gt
(<) 小于 - $lt
(>=) 大于等于 - $gte
(<= ) 小于等于 - $lte
--设数据库中有如下三条数据，以此为例进行条件操作符的举例
>db.col.insert({
    title: 'PHP 教程',
    description: 'PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['php'],
    likes: 200
})
>db.col.insert({title: 'Java 教程',
    description: 'Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['java'],
    likes: 150
})
>db.col.insert({title: 'MongoDB 教程',
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb'],
    likes: 100
})
--测试语句如下所示
--db.col.find({likes : {$gt : 100}})    =    Select * from col where likes > 100;
{"_id" : ObjectId("5cce8d424384432f5c739b49"),
"title" : "PHP 教程",
"description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
  "php"
],
"likes" : 200
},

{"_id" : ObjectId("5cce8d6c4384432f5c739b4a"),
"title" : "Java 教程",
"description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
"java"
],
"likes" : 150
}
--db.col.find({likes : {$gte : 150}}) = Select * from col where likes >=150;
/* 1 createdAt:2019/5/5 下午3:14:10*/
{"_id" : ObjectId("5cce8d424384432f5c739b49"),
"title" : "PHP 教程",
"description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
"php"
],
"likes" : 200
},

{"_id" : ObjectId("5cce8d6c4384432f5c739b4a"),
"title" : "Java 教程",
"description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
  "java"
],
"likes" : 150
}
--db.col.find({likes : {$lt : 150}}) = Select * from col where likes < 150;
{"_id" : ObjectId("5cce8d7e4384432f5c739b4b"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
  "mongodb"
],
"likes" : 100
}
--db.col.find({likes : {$lte : 150}}) = Select * from col where likes <= 150;
{"_id" : ObjectId("5cce8d6c4384432f5c739b4a"),
"title" : "Java 教程",
"description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
  "java"
],
"likes" : 150
},

{"_id" : ObjectId("5cce8d7e4384432f5c739b4b"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
"mongodb"
],
"likes" : 100
}
--db.col.find({likes : {$lt :200, $gt : 100}}) = Select * from col where likes>100 AND likes<200;
{"_id" : ObjectId("5cce8d6c4384432f5c739b4a"),
"title" : "Java 教程",
"description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。",
"by" : "菜鸟教程",
"url" : "http://www.runoob.com",
"tags" : [
"java"
],
"likes" : 150
}

-------------------------------------------------------------------------$type 操作符-------------------------------------------------------------------------
--$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。
--BSON（）是一种类json的一种二进制形式的存储格式，简称Binary JSON，它和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型
----------------------------------------
--字段类型                 | 对应编号   |
   Double    |   1 |
   String    |   2        |
   Object |   3        |
   Array |   4        |
   Binary data             |   5        |
   Object id |   7        |
   Boolean    |   8        |
   Date    |   9        |
   Null |   10       |
   Regular Expression      |   11       |
   JavaScript |   13       |
   Symbol    |   14       |
   JavaScript (with scope) |   15       |
   32-bit integer    |   16       |
   Timestamp               |   17       |
   64-bit integer    |   18       |
   Min key    |   255      |
   Max key |   127      |
----------------------------------------
--如下例所示：
--插入以下三条数据，其中第三条数据的'likes'字段为字符串
db.col.insert({
    title: 'PHP 教程',
    description: 'PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['php'],
    likes: 200
})

db.col.insert({title: 'Java 教程',
    description: 'Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['java'],
    likes: 150
})

db.col.insert({title: 'MongoDB 教程',
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb'],
    likes: '100'
})
--执行db.col.find({"likes" : {$type : 1}})或db.col.find({"likes" : {$type : Double}})以后，得到下面两条数据
db.col.insert({
    title: 'PHP 教程',
    description: 'PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['php'],
    likes: 200
})

-------------------------------------------------------------------------Limit与Skip方法-------------------------------------------------------------------------
--limit方法可通过输入一个参数来指定读取条数数据，格式如下：
db.COLLECTION_NAME.find().limit(NUMBER)
--同样以集合'col'为例，执行如下操作：
db.col.find({},{"title":1,_id:0}).limit(2)
--该查询执行了db.col.find({query},{url:1,description:1})格式，因为不设定查询条件，所以query可为空，需要返回title，所以设为1，因为不需要返回_id，所以设为0，
--唯有主键字段可设置为跟其他字段不同状态
--查询结果如下所示：
{ "title" : "PHP 教程" }
{ "title" : "Java 教程" }

--skip方法可通过输入一个参数来跳过指定的数据，格式如下：
b.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
--用法类似于limit

-------------------------------------------------------------------------sort排序-------------------------------------------------------------------------
--MongoDB 中使用 sort() 方法,通过参数指定排序的字段,对数据进行排序，参数为 1 和 -1 ，其中 1 表示升序排列， -1 表示降序排列，格式如下：
db.COLLECTION_NAME.find().sort({KEY:1})
--同样以集合'col'为例，执行如下操作：
db.col.find({},{"title":1,_id:0}).sort({"likes":1})
--查询结果如下所示：
{"title" : "MongoDB 教程"},
{"title" : "Java 教程"},
{"title" : "PHP 教程"}
--skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()。

-------------------------------------------------------------------------MongoDB 索引-------------------------------------------------------------------------
--MongoDB使用 createIndex() 方法来创建索引，格式如下：
db.collection.createIndex(keys:1/-1, options)
--语法中 Key 值为你要创建的索引字段，1 为指定按升序创建索引，-1 指定按降序创建索引，options表示可以用一个字段，也可以用多个字段，如下例：
db.col.createIndex({"title":1,"description":-1})
--createIndex() 接收可选参数，可选参数列表如下：

--参数名称                   参数类型参数作用
background                  Boolean 建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，
   即增加 "background" 可选参数。 "background" 默认值为false。
unique                      Boolean 建立的索引是否唯一。指定为true创建唯一索引。默认值为false.
name                        string 索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成
   一个索引名称。
dropDups                    Boolean    3.0+版本已废弃。在建立唯一索引时是否删除重复记录,指定 true 创建唯一
   索引。默认值为 false.
sparse                      Boolean 对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为
   true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false.
expireAfterSeconds          integer               指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
v                           index version 索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。
weights                     document    索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得
   分权重。
default_language            string    对于文本索引，该参数决定了停用词及词干和词器的规则的列表。默认为英语
language_override           string 对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language
，默认值为 language.
--参数的使用如下例所示：5
db.values.createIndex({open: 1, close: 1}, {background: true})
--通过在创建索引时加 background:true 的选项，让创建工作在后台执行
--查看集合索引
db.col.getIndexes()
---
db.col.totalIndexSize()
--删除集合所有索引
db.col.dropIndexes()
--删除集合指定索引
db.col.dropIndex("索引名称")
/*利用 TTL 集合对存储的数据进行失效时间设置：经过指定的时间段后或在指定的时间点过期，MongoDB 独立线程去清除数据。
类似于设置定时自动删除任务，可以清除历史记录或日志等前提条件，设置 Index 的关键字段为日期类型 new Date(),且不支持混合索引*/
--例如数据记录中 createDate 为日期类型时,设置时间180秒后自动清除
db.col.createIndex({"createDate": 1},{expireAfterSeconds: 180})
--由记录中设定日期点清除:设置 A 记录在 2019 年 1 月 22 日晚上 11 点左右删除，A 记录中需添加 "ClearUpDate": new Date('Jan 22, 2019 23:00:00')，且 Index中expireAfterSeconds 设值为 0。
--在数据中，ClearUpDate字段需要放置时间，{"ClearUpDate": 1}即按照ClearUpDate正序排列，此时{expireAfterSeconds: 0}则表示expireAfterSeconds默认取ClearUpDate第一条数据的时间
db.col.createIndex({"ClearUpDate": 1},{expireAfterSeconds: 0})

-------------------------------------------------------------------------MongoDB 聚合-------------------------------------------------------------------------
--aggregate方法主要用于处理数据，并返回计算后的数据结果，类似sql语句中的 count(*)，语法格式如下：
db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
--monmgodb常见的聚合函数如下所示：
--函数名称          意义                                                      案例
$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"}}}])
--沿用上文中表col中的数据，如下例所示：
db.col.aggregate([{$group : {_id : "$by", num_tutorial : {$sum : "$likes"}}}])
--此处将_id设为by，指定num_tutorial为汇总字段likes的值，得出结果让如下所示：
{"_id" : "菜鸟教程",
"num_tutorial" : 450
}

--MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
--表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档，，常见管道处理命令如下所示：
$project : 修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
$match   : 用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
$limit   : 用来限制MongoDB聚合管道返回的文档数。
$skip    : 在聚合管道中跳过指定数量的文档，并返回余下的文档。
$unwind : 将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
$group   : 将集合中的文档分组，可用于统计结果。
$sort    : 将输入文档排序后输出。
$geoNear : 输出接近某一地理位置的有序文档。
--如下例所示：
db.car.aggregate({$group:{_id:null,name:{$push:'$carname'}})
--此外，使用管道符以后，查询结果虽然改变，但是在数据库中的数据本身并未改变，如下例所示：
db.car.insert({ "_id" : ObjectId("5c2ec81a1590d9e9886e30f8"), "carname" : "大众", "color" : "red", "price" : 120 })
db.car.insert({ "_id" : ObjectId("5c2ec81a1590d9e9886e30f9"), "carname" : "奔弛", "color" : "bule", "price" : 400000 })
db.car.insert({ "_id" : ObjectId("5c2ec81a1590d9e9886e30fa"), "carname" : "宝马", "color" : "green", "price" : 300000 })
db.car.insert({ "_id" : ObjectId("5c2ec81a1590d9e9886e30fb"), "carname" : "奔弛", "color" : "red", "price" : 600000 })
db.car.insert({ "_id" : ObjectId("5c2ec81a1590d9e9886e30fc"), "carname" : "大众", "color" : "yellow", "price" : 100 })
db.car.insert({ "_id" : ObjectId("5c2ec81a1590d9e9886e30fd"), "carname" : "大众", "color" : "yellow", "price" : 120 })
--新建car表，并插入6条新数据，执行如下语句
db.car.aggregate({$project:{_id:0,carname:'玛莎拉蒂'}})
--输出结果如下所示：
{"carname" : "玛莎拉蒂"},
{"carname" : "玛莎拉蒂"},
{"carname" : "玛莎拉蒂"},
{"carname" : "玛莎拉蒂"},
{"carname" : "玛莎拉蒂"},
{"carname" : "玛莎拉蒂"}
--此时继续执行如下语句可发现原表中数据并未改变
{ "_id" : ObjectId("5c2ec81a1590d9e9886e30f8"), "carname" : "大众", "color" : "red", "price" : 120 }
{ "_id" : ObjectId("5c2ec81a1590d9e9886e30f9"), "carname" : "奔弛", "color" : "bule", "price" : 400000 }
{ "_id" : ObjectId("5c2ec81a1590d9e9886e30fa"), "carname" : "宝马", "color" : "green", "price" : 300000 }
{ "_id" : ObjectId("5c2ec81a1590d9e9886e30fb"), "carname" : "奔弛", "color" : "red", "price" : 600000 }
{ "_id" : ObjectId("5c2ec81a1590d9e9886e30fc"), "carname" : "大众", "color" : "yellow", "price" : 100 }
{ "_id" : ObjectId("5c2ec81a1590d9e9886e30fd"), "carname" : "大众", "color" : "yellow", "price" : 120 }

--在mongodb中连用count和distinct方法的语句如下所示：
db.runCommand({"distinct":"col","key":"by","query":{"url":"http://www.runoob.com"}})
--其中，"distinct"规定查询的表格名称，"key"规定了需要去重的字段，"query"规定了支持查询的其他约束条件，在开头调用runCommand方法，可以求出去重后的数据量！
--注意：查询的结果集大于16M 时会查询失败

-------------------------------------------------------------------------MongoDB 聚合-------------------------------------------------------------------------