# 1、备份源文件

sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak

# 2、添加源到 sources.list 中

sudo gedit /etc/apt/sources.list

# 在打开的文本中，添加阿里源

deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse

# 3、更新源

sudo apt-get update

# 安装依赖包

sudo apt-get install libcurl4 openssl

# 关闭和卸载原有的 mongodb

service mongodb stop

sudo apt-get remove mongodb

# 导入包管理系统使用的公钥

wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -

# 如果命令执行结果没有显示 OK，则执行此命令在把上一句重新执行：sudo apt-get install gnupg

# 注册 mongodb 源

echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list

# 更新源

sudo apt-get update

# 安装 mongodb

sudo apt-get install -y mongodb-org=4.4.2 mongodb-org-server=4.4.2 mongodb-org-shell=4.4.2 mongodb-org-mongos=4.4.2 mongodb-org-tools=4.4.2

# 安装过程中如果提示: mongodb-org-tools : 依赖: mongodb-database-tools 但是它将不会被安装

# 终端下运行以下命令，解决:

# sudo apt-get autoremove mongodb-org-mongos mongodb-org-tools mongodb-org

# sudo apt-get install -y mongodb-org=4.4.2

# 创建数据存储目录

sudo mkdir -p /data/db

# 修改配置，开放 27017 端口

sudo vim /etc/mongod.conf

# 把 12 行附近的 port=27017 左边的 #号去掉

# 重新加载配置，并启动 mongodb

sudo systemctl daemon-reload

sudo systemctl start mongod

# 查看运行状态

sudo systemctl status mongod

# 如果 mongodb 状态为 stop，则运行 sudo systemctl enable mongod

# 停止 mongodb

sudo systemctl stop mongod

# 重启 mongodb

sudo systemctl restart mongod

# 进入交互终端

mongo

MongoDB shell version v4.4.2

connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb

Implicit session: session { "id" : UUID("2c920d56-ddbb-4649-9191-a3bd4506a2d2") }

MongoDB server version: 4.4.2

---

The server generated these startup warnings when booting: 

        # 警告：强烈建议使用 XFS 文件系统，并使用 WiredTiger 存储引擎。

        # 解释：因为当前 ubuntu 使用的是 ext4 文件系统，mongodb 官方建议使用 XFS 文件系统功能更能发挥 mongodb 的性能，忽略不管

        2020-11-23T16:23:34.416+08:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem

        # 警告：当前 mongodb 没有为数据库启用访问控制。对数据和配置的读写访问是不受限制的。

        # 解释：后面会创建数据库用户采用密码登陆的。暂时不用管

        2020-11-23T16:23:35.046+08:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted

exit

# quit()

mongo --version

# 或者终端内部使用 version ()

db.help()                    help on db methods

    db.mycoll.help()             help on collection methods

    sh.help()                    sharding helpers  分片

    rs.help()                    replica set helpers 复制集

    help admin                   administrative help

    help connect                 connecting to a db help

    help keys                    key shortcuts

    help misc                    misc things to know

    help mr                      mapreduce

    show dbs                     show database names

    show collections             show collections in current database

    show users                   show users in current database

    show profile                 show most recent system.profile entries with time >= 1ms

    show logs                    show the accessible logger names

    show log [name]              prints out the last segment of log in memory, 'global' is default

    use <db_name>                set current database

    db.mycoll.find()             list objects in collection mycoll

    db.mycoll.find( { a : 1 } )  list objects in mycoll where a == 1

    it                           result of the last line evaluated; use to further iterate

    DBQuery.shellBatchSize = x   set default number of items to display on shell

    exit                         quit the mongo shell

show logs

# global

# startupWarnings

# 如果要查看具体文件的日志。

show log global

mongodump -h dbhost -d dbname -o dbdirectory

mongorestore -h dbhost -d dbname --dir dbdirectory

mongoexport -d dbname -c collectionname -o file --type json/csv -f field

mongoimport -d dbname -c collectionname --file filename --headerline --type json/csv -f field

db.createUser(user, writeConcern)

use mofang

show users

use admin

db.auth("root","123456")

db.system.users.find() # 只能在 admin 数据库中使用。

db.system.users.remove(json条件)

# 有多种删除方式，下面是根据 user 用户名删除用户

db.system.users.remove({user:"mofang"});

# 删除效果：

WriteResult({ "nRemoved" : 1 })  # nRemoved 大于 0 表示成功删除管理员，等于 0 则表示没有删除。

use mofang

# 注册必须保证有这个管理员

db.changeUserPassword("mofang", "123456")

sudo vim /etc/mongod.conf

# 找到 31 行附近的 security，去掉左边注释符号 (#)

security:

    authorization: enabled

:wq

# 重启 mongdb，配置生效

sudo systemctl restart mongod

# 开启了账户认证机制以后，再次进入 mofang

mongo

use mofang

show users    # 此处会报错如：uncaught exception: Error: command usersInfo requires authentication

db.auth("mofang","123")   # 此处认证时填写错误密码，报错如下：

# Error: Authentication failed.

# 0

db.auth("mofang","123456")  # 此处认证时填写正确密码，效果如下：

# 1

show users    # 此时经过认证以后，当前命令就不会被限制了。

sudo pkill mongod                              # 杀死 mongod 服务

sudo mongod -f /etc/mongod.conf --fork --auth  # --auth 表示以认证模式启动服务，不加则关闭

show dbs

show databases

use  <database>

db

db.getName()

db.dropDatabase()

> db.stats()

{

    "db" : "mofang",

    "collections" : 0,

    "views" : 0,

    "objects" : 0,

    "avgObjSize" : 0,

    "dataSize" : 0,

    "storageSize" : 0,

    "totalSize" : 0,

    "indexes" : 0,

    "indexSize" : 0,

    "scaleFactor" : 1,

    "fileSize" : 0,

    "fsUsedSize" : 0,

    "fsTotalSize" : 0,

    "ok" : 1

}

show collections # 或 show tables   或 db.getCollectionNames ()

db.集合.drop()

db.getCollection("集合")

db.集合

MongoDB Enterprise > db.user_list

mofang.user_list

db.printCollectionStats()

# 添加文档

# 方式 1：

db.集合.insert(<document>)  # document 就是一个 json

# 方式 2：       

db.集合.insertOne(          # 如果文档存在_id 主键为更新数据，否则就添加数据。

   <document>

)

# 方式 3

# 一次性添加多个文档，多次给同一个集合建议使用 insertMany 比 insertOne 效率更好

db.集合.insertMany(

   [ <document> , <document>, ... ]

)

use mofang;

// 添加一条数据

db.user_list.insert({"name":"laoli","age":33,"sex":true,"child":{"name":"xiaohuihui","age":3}});

// WriteResult({ "nInserted" : 1 })

// 添加一条数据

db.user_list.insertOne({"name":"xiaozhang","age":18,"sex":true});

// {

//     "acknowledged" : true,

//     "insertedId" : ObjectId("605021e6d5c7a55cc95c1cb7")

// }

// 添加多条数据

document1 = {"name":"xiaolan","age":16}

document2 = {"name":"xiaoguang","age":16}

db.user_list.insertMany([document1,document2]);

// {

//     "acknowledged" : true,

//     "insertedIds" : [

//         ObjectId("60502235d5c7a55cc95c1cba"),

//         ObjectId("60502235d5c7a55cc95c1cbb")

//     ]

// }

db.集合.remove(

   <query>,  // removed的条件，一般写法：{"属性":{条件:值}}，如果不填写条件，删除所有文档

   {

     justOne: <boolean>,      // 可选删除，是否只删除查询到的第一个文档，默认为false，删除所有

     writeConcern: <document> // 可选参数，抛出异常的级别。

   }

)

// 删除满足条件的第一条数据

db.user_list.remove({"age":17},{"justOne":true})

// 删除满足条件的所有数据

db.user_list.remove({"name":"laowang"});

db.user_list.find({"age":{$lte:18}})

db.user_list.find({"age":{$gte:18}})

db.user_list.find({"age":{$in:[16,33]}})

db.user_list.find({"child.age":{$in:[3]}})

// 查询age=18 并且 sex=true

db.user_list.find({

    $and:[

        {"age":{$eq:18}},

        {"sex":{$eq:true}}

    ]

})

// 简写：

db.user_list.find({

    $and:[

        {"age":18},

        {"sex":true}

    ]

})

// 继续简写；

db.user_list.find({ "age":18, "sex":true})

// 查询age=16或者age=18

db.user_list.find({

    $or:[

        {"age":{$eq:16}},

        {"age":{$eq:18}}

    ]

})

// 查询年龄!=16的

db.user_list.find({"age":{$not:{$eq:16}}})

db.user_list.find({"age":{$ne:16}})

// 查询age=33的男生 或者 age=18的男生

db.user_list.find({

    "sex":true,

    $or:[

        {"age":18},

        {"age":33}

    ]

});

db.user_list.find({

    "sex":true,

    "age":{

        $in:[18,33]

     }

});

db.user_list.find({

    $or:[

        {$and:[{"sex":true},{"age":18}]},

        {$and:[{"sex":true},{"age":33}]},

    ]

});

db.user_list.find({

    $or:[

        {"sex":true,"age":18},

        {"sex":true,"age":33},

    ]

});

db.user_list.insert({"name":"xiaoming","sex":0,"age":"18"});

db.user_list.insert({"name":"xiaoming","sex":1,"age":"18"});

db.user_list.insert({"name":"xiaoming","sex":1,"age":"33"});

db.user_list.insert({"name":"xiaoming","sex":0,"age":"33"});

// $type

db.user_list.find({"sex":{$type:"number"}});

db.user_list.find({"age":{$type:"string"}});

// $exists

db.user_list.find({"child":{$exists:true}});

// $regex 正则匹配

db.user_list.insert({"name":"xiaoming","sex":0,"age":"18","mobile":"13301234568"});

db.user_list.insert({"name":"xiaoming","sex":1,"age":"18","mobile":"1351234568"});

db.user_list.insert({"name":"xiaoming","sex":1,"age":"33","mobile":"15001234568"});

db.user_list.insert({"name":"xiaoming","sex":0,"age":"33","mobile":"15001234568"});

// 符合手机格式

db.user_list.find({"mobile":{$regex: /1[3-9]\d{9}/ }});

// 不符合手机号码格式的

db.user_list.find({"mobile":{$not:{$regex: /1[3-9]\d{9}/ }}});

// $mod

db.user_list.find({"age":{$mod: [3,0] }});

db.user_list.find({$where: function(){

    return this.name=="xiaoming" && this.age<30;

}});

// 把字符串作为代码条件执行,当结果为true,则返回当前符合的数据

db.user_list.find({$where:"this.name=='xiaoming' && this.age>30"});

db.集合.find().sort({<key>:1})  // 升序,默认为升序

db.集合.find().sort({<key>:-1}) // 倒序,

db.user_list.find().sort({"age":-1});

> db.user_list.find({"mobile":{$regex:/^133\d{8}$/}},{"_id":0}).sort({"mobile":-1})

    { "name" : "xiaoming", "mobile" : "13333355678" }

    { "name" : "xiaoming", "mobile" : "13333345678" }

    { "name" : "xiaoming", "mobile" : "13312345678" }

> db.user_list.find({"mobile":{$regex:/^133\d{8}$/}},{"_id":0,"name":0}).sort({"mobile":-1})

    { "mobile" : "13333355678" }

    { "mobile" : "13333345678" }

    { "mobile" : "13312345678" }

> db.user_list.find({"mobile":{$regex:/^133\d{8}$/}},{"name":1}).sort({"mobile":-1})

    { "_id" : ObjectId("60502fb7d5c7a55cc95c1cc4"), "name" : "xiaoming" }

    { "_id" : ObjectId("60502fb4d5c7a55cc95c1cc3"), "name" : "xiaoming" }

    { "_id" : ObjectId("60502fb1d5c7a55cc95c1cc2"), "name" : "xiaoming" }

> db.user_list.find({"mobile":{$regex:/^133\d{8}$/}},{"name":1,"_id":0}).sort({"mobile":-1})

    { "name" : "xiaoming" }

    { "name" : "xiaoming" }

    { "name" : "xiaoming" }

db.user_list.find({},{"_id":0,"name":1,"age":1}).sort({"age":1}).limit(5);

db.user_list.find({},{"_id":0,"name":1,"age":1}).sort({"age":1}).limit(5).skip(5);

// 更新一条

db.集合.update(

   <query>,   // update的查询条件，一般写法：{"属性":{条件:值}}

   <update>,  // update的更新数据，一般写法 { $set:{"属性":"值"} } 或者 { $inc:{"属性":"值"} }

   {

     upsert: <boolean>, // 可选参数，如果文档不存在，是否插入objNew, true为插入，默认是false，不插入

     multi: <boolean>,  // 可选参数，是否把满足条件的所有数据全部更新，设置更新1条还是多条

     writeConcern: <document> // 可选参数，抛出异常的级别。

   }

)

// 更新多条

db.集合.updateMany(

   <query>,   // update的查询条件，一般写法：{"属性":{条件:值}}

   <update>,  // update的对象，一般写法 { $set:{"属性":"值"} } 或者 { $inc:{"属性":"值"} }

   {

     upsert: <boolean>, // 可选参数，如果文档不存在，是否插入objNew, true为插入，默认是false，不插入

     multi: <boolean>,  // 可选参数，是否把满足条件的所有数据全部更新

     writeConcern: <document> // 可选参数，抛出异常的级别。

   }

)

// $inc

// 把laoli的年龄+10岁

db.user_list.update({"name":"laoli"},{$inc:{"age":10}}); // 更新一条

db.user_list.updateMany({"name":"laoli"},{$inc:{"age":10}}); // 更新多条

// 把laoli的孩子年龄+10岁

db.user_list.update({"name":"laoli"},{$inc:{"child.age":10}});

// $set

//更新laoli的手机号码

db.user_list.update({"name":"laoli"},{$set:{"mobile":"18012312312"}}); // 更新一条

// 更新laoli孩子的手机号码

db.user_list.update({"name":"laoli"},{$set:{"child.mobile":"18012312312"}});

// $unset

// 移除laoli的性别键值对

db.user_list.update({"name":"laoli"},{$unset:{"sex":true}});

// $push

db.user_list.update({"name":"laoli"},{$set:{"lve":["TV","game"]}});

db.user_list.update({"name":"laoli"},{$push:{"lve":"code"}}); // 往列表属性中追加成员

// $addToSet 结合 $each 把一个数组中每一个成员添加到数组中

db.user_list.update({"name":"laoli"},{$addToSet:{"lve":{$each:["code","music","TV"]}}});

// $pull

db.user_list.update({"name":"laoli"},{$pull:{"lve":["walk","music"]}});

// $pop

db.user_list.update({"name":"laoli"},{$pop:{"lve":-1}}); // 左边移除列表的第一个成员

db.user_list.update({"name":"laoli"},{$pop:{"lve":1}}); // 右边移除列表的最后一个成员

// $rename 字段名重命名

db.user_list.update({"name":"laoli"},{$rename:{"love":"lve"}});

fotmatnumber = function(start, end){

    num = Math.round(Math.random() * (end-start)) + start

    if(num<10){

        return "0"+num;

    }else{

        return num;

    }

}

rand_title = function(i){

    num = Math.round( Math.random() * 10 );

    num1 = Math.round( Math.random() * 10 );

    return [

        "赠送礼品-"+num,

        "购物狂欢-"+num,

        "随便买买-"+num,

        "愉快购物-"+num,

        "赠送礼物-"+num,

        "商品购买-"+num,

        "买多送多-"+num,

        "买年货-"+num,

        "买买买买-"+num

    ][num1];

}

for(var i=0; i<50000; i++){  

    db.orders.insert({

        "onumber": ( "0000000000000000" + i ).substr( String(i).length ),  

        "date": "20"+fotmatnumber(0,21)+"-"+fotmatnumber(1,12)+"-"+fotmatnumber(1,31),  

        "title": rand_title(i),

        "user_id": parseInt(i/200)+1,

        "items" :[{ 

            "goods_id" : parseInt(i/200)+1,

            "goods_attr" : i,  

            "price" : 100.0

        },{ 

            "goods_id" : parseInt(i/200)+2,

            "goods_attr" : i+1,  

            "price" : 80.0

        }]

    })

    if(i%10000==0){

        print("已经添加了"+parseInt(i/10000)+"万条数据！");

    }

}

// 获取当前集合中已经创建的所有索引信息

db.集合.getIndexes()

/*

[{ 

    "v" : 2,   // 索引版本

    "key" : {  // 索引的字段及排序方向(1表示升序，-1表示降序)

        "_id" : 1   // 根据_id字段升序索引

    }, 

    "name" : "_id"   // 索引的名称

}]

*/

// 获取当前集合中已经创建的索引总大小，以字节为单位返回结果

db.集合.totalIndexSize()

// 获取当前数据库中所有的索引【不会显示_id主键】

db.system.indexes.find()

db.orders.find({"title":"购买商品-19"}).explain("executionStats");

/*

{

    "queryPlanner" : {  # 被查询优化器选择出来的查询计划

        "plannerVersion" : 1,  # 查询计划版本

        "namespace" : "test.orders", # 要查询的集合

        "indexFilterSet" : false,  # 是否了使用索引

        "parsedQuery" : {  # 查询条件

            "title" : {

                "$eq" : "购买商品-19"

            }

        },

        "winningPlan" : {     # 最佳执行计划

            "stage" : "COLLSCAN", # 扫描类型 / 扫描阶段

            "filter" : {     # 过滤条件

                "title" : {

                    "$eq" : "购买商品-19"

                }

            },

            "direction" : "forward"  # 查询方向，forward 为升序，backward 表示倒序。

        },

        "rejectedPlans" : [ ]   # 拒绝的执行计划

    },

    "executionStats" : {  # 最佳执行计划的一些统计信息

        "executionSuccess" : true,  # 是否执行成功

        "nReturned" : 1,   # 返回的结果数

        "executionTimeMillis" : 346,  # 执行耗时

        "totalKeysExamined" : 0,      # 索引扫描次数

        "totalDocsExamined" : 1000000,  # 文档扫描次数，所谓的优化无非是让 totalDocsExamined 和 nReturned 的值接近。

        "executionStages" : {     # 执行状态

            "stage" : "COLLSCAN",  # 扫描方式 / 扫描阶段

            "filter" : {

                "title" : {

                    "$eq" : "购买商品-19"

                }

            },

            "nReturned" : 1,   # 返回的结果数

            "executionTimeMillisEstimate" : 5,   # 预估耗时

            "works" : 1000002,   # 工作单元数

            "advanced" : 1,      # 优先返回的结果数

            "needTime" : 1000000,

            "needYield" : 0,

            "saveState" : 1000,

            "restoreState" : 1000,

            "isEOF" : 1,

            "direction" : "forward",

            "docsExamined" : 1000000   # 文档检查数目，与 totalDocsExamined 一致

        }

    },

    "serverInfo" : {   # 服务器信息

        "host" : "ubuntu",

        "port" : 27017,

        "version" : "4.4.2",

        "gitVersion" : "15e73dc5738d2278b688f8929aee605fe4279b0e"

    },

    "ok" : 1

}

*/

// 创建索引

db.集合.createIndex({

    // 单个字段，则为普通索引，    // sort的值表示排序，值为1表示升序索引，-1表示降序索引

    "字段名1": <sort|type>,       // type的值可以是text，表示创建全文索引。db.集合.find({$text:{$search:"字符串"}})

    "字段名2": <sort|type>,       // 多个字段，则为复合索引

    "字段名3": [<值1>,<值2>,...],  // 多列索引

    ....

}, {

    background: <Boolean>,   // 建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，默认为false

    unique: <Boolean>,  // 是否建立唯一索引，默认值为false，也叫唯一索引

    name: <String>,   // 索引的名称，不填写，则MongoDB会通过连接索引的字段名和排序顺序生成一个索引名称 

    expireAfterSeconds: <integer>, // 设置索引的过期时间，类似redis的expire，也叫TTL索引

    sparse: <Boolean>,  // 对文档中不存在的字段数据是否不启用索引，默认为False

});

// 单字段索引[普通索引]

 db.集合.createIndex({

    "字段名1": <sort>,    // sort的值表示排序，值为1表示升序索引，-1表示降序索引

 }, {

    ....

 })

// 普通索引创建： db.orders.createIndex({"title":1})

// 查询基本使用： db.orders.find({"title":"购买商品-19"})

// 多字段索引，也叫复合索引。[类似mysql里面的联合索引]

 db.集合.createIndex({

    "字段名1": <sort>,    // sort的值表示排序，值为1表示升序索引，-1表示降序索引

    "字段名2": <sort>,    // sort的值表示排序，值为1表示升序索引，-1表示降序索引

 }, {

    ....

 })

// 复合索引的使用对单条件的查找是没有帮助的，必须多字段[必须包含复合索引的字段]条件使用

// 复合索引创建：db.orders.createIndex({"date":1,"title":1});

// 查询基本使用：

//     db.orders.find({"date":"2020-09-01","title":"购买商品-1007"});

//     db.orders.find({"date":"2020-09-01","onumber":"0000000000001007","title":"购买商品-1007","onumber":});

// 全文索引

 db.集合.createIndex({

    "字段名1": <type>,    // type的值只能是text，表示创建全文索引。db.集合.find({$text:{$search:"字符串"}})

 }, {

    ....

 })

// 全文索引创建： db.orders.createIndex({"title":"text"})

// 查询基本使用： db.orders.find({$text:{$search:"商品-19"}}).explain("executionStats")

// 多列索引[应用的地方是在列表属性]

 db.集合.createIndex({

    "字段名3": [<值1>,<值2>,...],

 }, {

    ....

 });

// 创建测试数据

db.doc.drop()

db.doc.insert({"title":"标题1","tags":["python","django"]})

db.doc.insert({"title":"标题1","tags":["python","django"]})

db.doc.insert({"title":"标题1","tags":["python","django"]})

db.doc.insert({"title":"标题2","tags":["java","mvp"]})

db.doc.insert({"title":"标题3","tags":["java","mvp"]})

db.doc.insert({"title":"标题2","tags":["java","mvp"]})

db.doc.insert({"title":"标题3","tags":["python"]})

db.doc.insert({"title":"标题4","tags":["python"]})

db.doc.insert({"title":"标题2","tags":["python","flask"]})

db.doc.insert({"title":"标题3","tags":["java"]})

// 创建多列索引： db.doc.createIndex({"tags":1})

// 查询数据： db.doc.find({"tags":["python"]}).explain("executionStats")

// 唯一索引

db.集合.createIndex({

    "字段名1": <sort>,

}, {

    unique: true,     // 是否建立唯一索引，默认值为false，也叫唯一索引

})

// 创建唯一索引： db.orders.createIndex({"onumber":1},{unique:true});

// 查询数据： db.orders.find({"onumber":"0000000000001019"}).explain("executionStats")

// ttl索引

// 使用ttl索引，索引关键字段必须是 Date 类型，如果该字段不是date类型或者文档中不存在该字段，则文档不会进行过期处理

// 数据过期的删除工作是在独立线程内执行的，默认平均60s扫描一次。

// 例如：在文档创建1小时后，删除文档

db.集合.createIndex({"date": 1},{expireAfterSeconds: 3600})

// 在文档创建后，由索引字段值指定的时间删除文档

db.集合.createIndex({"date": 1},{expireAfterSeconds: 0}) // 文档中date字段对应的时间就变成了过期时间了.

db.集合.insert( {

   "date": new Date('2020-02-06 10:00:00'), // 在python中需要通过 utctime

   "user_id": 2,

   "username": "xiaoming"

})

// 创建索引：db.tasks.createIndex({"expire_time":1},{expireAfterSeconds:0})

// 创建测试数据

db.tasks.insert( {

   "expire_time": new Date('2021-06-17 22:24:00'), // 在python中需要通过 utctime

   "user_id": 2,

   "username": "xiaoming"

});

db.tasks.insert( {

   "expire_time": new Date('2021-06-17 18:25:00'), // 在python中需要通过 utctime

   "user_id": 2,

   "username": "xiaoming"

});

db.tasks.insert( {

   "expire_time": new Date('2021-06-17 18:27:00'), // 在python中需要通过 utctime

   "user_id": 2,

   "username": "xiaoming"

});

// 重建索引[一般是在长期项目运行下来，索引创建时间太久了，性能下降的时候使用。不能在高峰期时运行]

db.集合.reIndex();

// 删除单个索引

db.集合.dropIndex("索引名称")

// 删除所有索引

db.集合.dropIndexes()