//创建用户名密码
use admin

db.createUser(
  {
    user: "mongo",
    pwd: "7f27cd7ae184274e2ca645f09183fc63",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  }
)

use dbName
db.collectionName.find / db.getCollection('collectionName').find
db.foo.update 查看update源码
对象{} 数组[]
一条数据是一个文档 多个文档是一个集合
bson：二进制json
将json转为bson存入数据库 bson大于4MB无法存入 V1.8：16MB
计算json转为bson大小 Object.bsonsize(doc)

与mysql中的字段对比说明

$project # 返回哪些字段,select,说它像select其实是不太准确的,因为aggregate是一个阶段性管道操作符,$project是取出哪些数据进入下一个阶段管道操作,真正的最终数据返回还是在group等操作中;

$match # 放在group前相当于where使用,放在group后面相当于having使用

$sort # 排序1升-1降 sort一般放在group后,也就是说得到结果后再排序,如果先排序再分组没什么意义;

$limit # 相当于limit m,不能设置偏移量

$skip # 跳过第几个文档

$unwind # 把文档中的数组元素打开,并形成多个文档,参考Example1

$group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... # 按什么字段分组,注意所有字段名前面都要加的是普通常量,其中accumulator又包括以下几个操作符
$sum,$avg,$first,$last,$max,$min,$push,$addToSet

如果group by null就是 count(*)的效果

$geoNear # 取某一点的最近或最远,在LBS地理位置中有用

$out # 把结果写进新的集合中。注意1,不能写进一个分片集合中。注意2,不能写进

db.getCollection('user').aggregate(
    [
    {$project:
        {phone:{$substr:['$phone', 0, 7]}}
        },
        {$group:
            {'_id':'$phone','count':{$sum:1}}
            }
    ]
    
)

更新：
//更新一条

db.sang_collect.update({x:1},{x:99})

//更新多条

db.collection.update({x:1},{$set:{x:99}},false,true)

第一个false表示如果不存在update记录，是否将我们要更新的文档作为一个新文档插入，true表示插入，false表示不插入，默认为false，第二个true表示是否更新全部查到的文档，false表示只更新第一条记录，true表示更新所有查到的文档。

//如果字段不存在则创建

db.collection.update({x:1},{$set:{x:99}})

//删除字段

db.collection.update({x:1},{$unset:{x:99}})

//修改内嵌文档

db.collection.update({name:"三国演义"},{$set:{"author.name":"明代罗贯中"}})

//inc只能用来操作数字，不能用来操作null、布尔等。

db.collection.update({name:"三国演义"},{$inc:{"author.age":1}})

//$push可以向已有数组末尾追加元素，要是不存在就创建一个数组

db.collection.update({name:"三国演义"},{$push:{comments:"好书666"}})

//如果想一次添加多条评论，可以结合push:{comments:{$each:["111","222","333"]}}})

//使用$slice来固定数组的长度 超出长度保留最新

db.collection.update({name:"三国演义"},{$push:{comments:{$each:["444","555"],$slice:5}}})

//使用$sort对数据先进行排序 执行顺序-1表示降序，1表示升序。 sort/slice

db.collection.update({class:"三年级二班"},{$push:{students:{$each:[{name:"张一百",score:100},{name:"张九九",score:99},{name:"张九八",score:98}],$slice:5,$sort:{score:-1}}}})
db.collection.update({'name':'三国演义'},{$push:{'comments':{$each:[1,2,3],$slice:5,$sort:1}}})

//表示要插入的值如果存在则不插入，否则插入 无法和sort和slice配合使用

db.getCollection('runoob').update({'name':'三国演义'},{$addToSet:{'comments':1}})
db.getCollection('runoob').update({'name':'三国演义'},{$addToSet:{'comments':{$each:[19,2,3]}}})

//$pop可以用来删除数组中的数据 1表示从comments数组的末尾删除一条数据，-1表示从comments数组的开头删除一条数据。

db.sang_collect.update({name:"三国演义"},{$pop:{comments:1}})

//使用$pull我们可以按条件删除数组中的某个元素

db.getCollection('runoob').update({'name':'三国演义'},{$pull:{students:{score:100}}})
db.getCollection('runoob').update({'name':'三国演义'},{$pull:{comments:1}})

//通过下标修改

db.getCollection('runoob').update({'name':'三国演义'},{$set:{'comments.0':22}})
db.getCollection('runoob').update({'name':'三国演义'},{$set:{'students.0.score':22}})
//不知道我要修改的数据处于数组中的什么位置，这个时候可以使用$符号来解决
db.getCollection('runoob').update({'students.score':22},{$set:{'students.$.score':33}})
db.getCollection('runoob').update({'comments':3},{$set:{'comments.$':33}})

//save是shell中的一个函数，接收一个参数，这个参数就是文档，如果文档中有_id参数save会执行更新操作，否则执行插入操作
db.sang_collect.save({x:111})

查询
//查询

db.sang_collect.find({x:1})

//查询 and

db.sang_collect.find({x:1,y:2})

//自定义返回字段 1表示返回 0表示不返回 _id默认返回

db.sang_collect.find({x:1},{x:1,_id:0})

//比较运算符

//比较运算符用法

db.sang_collect.find({key:{$ne:value}})

// 查询在某个集合里 $in

db.collection.find({key:{$in:[value1,value2,……]}})

//$nin 查询不在某个集合

db.collection.find({key:{$nin:[value1,value2,……]}})

//$or 查询或

db.collection.find({key:{$or:[{key1:value1},{key2:value2},……]}})

//$type 根据数据类型查找

db.collection.find({key:{$type:1}})

//1表示数字，其他数据类型对应的数字参见下表。

//$not 可以配合表达式查询 $type/$lte……
db.collection.find({key:{$not:{$gte:2}}})

//$and

db.collection.find({$and:[{key:{$gte:value}},{key:{$lte:value}}]})

//null 查询某个字段为null的文档

db.collection.find({key:null}) //会查询出字段不存在的数据
db.collection.find({key:{$in:[null], $exists:true}})

//正则查询

db.collection.find({key://})

//数组查询

{
    "_id" : ObjectId("59f208bc7b00f982986c669c"),
    "x" : [ 
        5.0, 
        25.0
    ]
}

db.collection.find({key:value}) //包含一个
db.collection.find{(key:{$all:[value1,value2……]}}) //包含多个
db.collection.find({key:[value1,value2……]})  //精确匹配
db.collection.find({key.2:value})  //根据下标精确匹配
db.collection.find({key:{$size:2}})  //数组长度匹配
db.collection.find({},{key:{$slice:2}})  //展示数组中前两条数据  正数：从前定位  负数：从后低定位
db.collection.find({},{key:{$slice:[1,3]}}) //展示数组区间  2-4

//$elemMatch 同时使用查询条件中的两个语句与一个数组元素进行比较。

db.collection.find({key:{$elemMatch:{$lt:value,$gt:vale}}})

//嵌套文档查询
{
    "_id" : ObjectId("59f20c9b7b00f982986c669f"),
    "x" : 1.0,
    "y" : {
        "z" : 2.0,
        "k" : 3.0
    }
}


db.collection.find({key:{key1:value1,key2:value2}})  //严格匹配  顺序敏感
db.collection.find({key.key1:value1,key.key2:value2})  //灵活

//游标
var cursor = db.collection.find();
while(cursor.hasNext())
{
    print(cursor.next())
}
while(cursor.hasNext())
{
    print(cursor.next().key)
}
cursor.forEach(function(x)
{
    print(x)
})

//limit

db.collection.find().limit(num)

//skip

db.collection.find().skip(num).limit(num)

//sort 1升序 -1降序

db.collection.find().sort({key:1})

explain

db.getCollection('runoob').find({x:1}).explain()

//result
{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "test.runoob",
        "indexFilterSet" : false,
        "parsedQuery" : {
            "x" : {
                "$eq" : 1.0
            }
        },
        "winningPlan" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "x" : {
                    "$eq" : 1.0
                }
            },
            "direction" : "forward"
        },
        "rejectedPlans" : []
    },
    "serverInfo" : {
        "host" : "hebin-P1",
        "port" : 27017,
        "version" : "3.2.22",
        "gitVersion" : "105acca0d443f9a47c1a5bd608fd7133840a58dd"
    },
    "ok" : 1.0
}

//返回结果包含两大块信息，一个是queryPlanner，即查询计划，还有一个是serverInfo，即MongoDB服务的一些信息

参数 含义
plannerVersion 查询计划版本
namespace 要查询的集合
indexFilterSet 是否使用索引
parsedQuery 查询条件，此处为x=1
winningPlan 最佳执行计划
stage 查询方式，常见的有COLLSCAN/全表扫描、IXSCAN/索引扫描、FETCH/根据索引去检索文档、SHARD_MERGE/合并分片结果、IDHACK/针对_id进行查询
filter 过滤条件
direction 搜索方向
rejectedPlans 拒绝的执行计划
serverInfo MongoDB服务器信息

//参数 executionStats 会返回最佳执行计划的一些统计信息

db.getCollection('runoob').find({x:1}).explain('executionStats')
//result
/* 1 */
{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "test.runoob",
        "indexFilterSet" : false,
        "parsedQuery" : {
            "x" : {
                "$eq" : 1.0
            }
        },
        "winningPlan" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "x" : {
                    "$eq" : 1.0
                }
            },
            "direction" : "forward"
        },
        "rejectedPlans" : []
    },
    "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 0,
        "executionTimeMillis" : 0,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 3,
        "executionStages" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "x" : {
                    "$eq" : 1.0
                }
            },
            "nReturned" : 0,
            "executionTimeMillisEstimate" : 0,
            "works" : 5,
            "advanced" : 0,
            "needTime" : 4,
            "needYield" : 0,
            "saveState" : 0,
            "restoreState" : 0,
            "isEOF" : 1,
            "invalidates" : 0,
            "direction" : "forward",
            "docsExamined" : 3
        }
    },
    "serverInfo" : {
        "host" : "hebin-P1",
        "port" : 27017,
        "version" : "3.2.22",
        "gitVersion" : "105acca0d443f9a47c1a5bd608fd7133840a58dd"
    },
    "ok" : 1.0
}

参数 含义
executionSuccess 是否执行成功
nReturned 返回的结果数
executionTimeMillis 执行耗时
totalKeysExamined 索引扫描次数
totalDocsExamined 文档扫描次数
executionStages 这个分类下描述执行的状态
stage 扫描方式，具体可选值与上文的相同
nReturned 查询结果数量
executionTimeMillisEstimate 预估耗时
works 工作单元数，一个查询会分解成小的工作单元
advanced 优先返回的结果数
docsExamined 文档检查数目，与totalDocsExamined一致

//参数 allPlansExecution 获取所有执行计划

索引 MongoDB限制每个集合上最多有64个索引
//默认_id是索引

//创建索引
db.collection.ensureIndex(key:1) //1升序 -1降序

//查看索引

db.collection.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test.runoob"
    },
    {
        "v" : 1,
        "key" : {
            "name" : 1.0
        },
        "name" : "name_1",  //索引名  默认 字段名_排序值
        "ns" : "test.runoob"
    }
]

//创建索引其它参数
db.collection.ensureIndex({x:1},{name:"myfirstindex",dropDups:true,background:true,unique:true,sparse:true,v:1,weights:99999})
//参数说明
1.name表示索引的名称
2.dropDups表示创建唯一性索引时如果出现重复，则将重复的删除，只保留第一个
3.background是否在后台创建索引，在后台创建索引不影响数据库当前的操作，默认为false
4.unique是否创建唯一索引，默认false
5.sparse对文档中不存在的字段是否不起用索引，默认false
6.v表示索引的版本号，默认为2
7.weights表示索引的权重

//查看索引大小
db.collection.totalIndexSize()

//删除索引
db.collection.dropIndex('indexName') //按名称删除
db.collection.dropIndexes() //删除所有索引