MongoDB入门操作

MongoDB
1. MongoDB的启动服务        
    1.开启服务      
    sudo mongod          
    2.开启客户端    
    mongo        
    权限  了解        
    sudo mongod --auth        
    use admin        
    db.createUser({"user":"A","pwd":"123456",roles:["root"]})        
    db.createUser({user:"B","pwd":"123456",roles:[{db:'stu',role:'read'}]})                
    db.auth('A','123456')        
    show  users        
    db.dropUser('A')
2.MongoDB的数据库操作         
    1.查看默认的数据库      db          
    2.查看所有的数据库      show dbs        
    3.查看所有的集合(表)    show collections               
    5.切换数据库           use  xx        
    6.删除数据库           
        1.进库 
        2.db.dropDatabase()     
        3.MongoDB中的集合(表)的操作        
            1.创建集合             
                db.createCollection('')            
            2.创建内容(文档)        
                db.insert({})        
            3.删除集合             
                db.xx.drop()        
            4.查询所有             
                db.xx.find()
        4.文档数据增,删,改        
            1.增加            
                1.1 直接增加             
                    db.xx.insert({})            
                1.2 先字典 在增加            
                    dict_data = {                
                        _id:1,                
                        name:"范冰冰",                
                        age:37,                
                        gender:true            
                    }            
                    db.stu.insert(dict_data)                           
                    db.stu.insert({_id:2,user:"小兰",age:16,gender:false})                
                    db.stu.insert({_id:3,user:"小芳",age:18,gender:false})                
                    db.stu.insert({_id:4,user:"大头儿子",age:8,gender:true})                
                    db.stu.insert({_id:5,user:"小头爸爸",age:38,gender:true})                
                    db.stu.insert({_id:7,user:"皮几万",age:25,gender:true})                
                    db.stu.insert({_id : 1, name:'郭靖',hometown:'蒙古',age:20,gender:true})                
                    db.stu.insert({_id : 2, name:'黄蓉',hometown:'桃花岛',age:18,gender:false})                
                    db.stu.insert({_id : 3, name:'华筝',hometown:'蒙古',age:18,gender:false})               
                    db.stu.insert({_id : 4, name:'黄药师',hometown:'桃花岛',age:40,gender:true})                
                    db.stu.insert({_id : 5, name:'段誉',hometown:'大理',age:16,gender:true})                
                    db.stu.insert({_id : 6, name:'段王爷',hometown:'大理',age:45,gender:true})                
                    db.stu.insert({_id : 7, name:'Lily',hometown:'英国',age:45,gender:true})        
            2. 删除数据            
                1.  默认删除所有符合条件的数据            
                    db.xx.remove({删除条件})            
                2. 只想删除符合条件的一个数据            
                    db.xx.remove({删除条件},{justOne:true})            
                3.删除所有的数据            
                    db.xx.remove({})        
                3. 修改数据                
                    db.xx.update(查询条件, 修改内容)                        
                    1. 默认修改或者新增字段; 其他的字段删除了            
                    2. 只修改或增加 原有的字段; 其他字段不变 保留 $set            
                        db.xx.update({查询},{$set:{age:18}})            
                        db.stu.update({gender:true},{$set:{user:"一家人"}})            
                    3. 只要符合条件 都修改  字段 {multi:true}                     
                    4. 删除字段  $unset            
                        db.stu.update(                
                            {                    
                                gender:true                
                            },                
                            {                    
                                $unset:{age:""}                
                            },                
                            {                    
                                multi:true                
                            }            
                        )
5.数据的基本查询:         
    1.基本查询{             
        1.查询所有的数据               
            db.stu.find()             
        2.指定条件查询              
            db.stu.find({条件})             
        3. 只查找符合条件的一个             
            db.stu.findOne()        
    }        
    2.条件运算 $lt $gt $lte $gte $ne        
    {         
        db.xx.find({字段:{修饰符:值}})             
        // 取出年龄大于 20岁的人            
        db.stu.find({age:{$lt:30}})             
        // 取出年龄不等于 20岁的                       
    }        
    3.逻辑运算 $and  $or         
        db.xx.find(             
            {                 
                $and:[                     
                    {条件1},                     
                    {条件2}                 
                    ]             
            }         
        )                          
        1. 默认find的多条件 就是 $and               
        //籍贯是 桃花岛 年龄是18岁的              
        db.stu.find({age:18,hometown:"桃花岛"})              
        db.stu.find(                  
            {                      
                $and:[                          
                    {age:18},                          
                    {hometown:"桃花岛"}                      
                    ]                  
            }              
        )            
        2. $or               
        // 来自大理 或者是女生的              
        db.stu.find(                  
            {                      
                $or:[                          
                    {hometown:"大理"},                          
                    {gender:false}                      
                ]                  
            }              
        )                                       
        3. 混合使用               
        // 来自桃花岛或者年龄小于45岁 必须是男生              
        db.stu.find(                  
            {                      
                $and:[                          
                    {                              
                        $or:[                                  
                            {hometown:"桃花岛"},                                  
                            {age:{$lt:45}}                              
                        ]                          
                    },                          
                    {gender:true}                      
                ]                  
            }              
        )                             
        // 来自大理或者来自蒙古   必须男的 年龄大于16
        }        
        4.范围运算符 $in  $nin              
            db.stu.find({age:{$in:[8,18]}})            
            db.stu.find({hometown:{$in:['大理','蒙古']}})                       
        5.正则表达式{               
            db.xx.find(                   
                {字段:'正则表达式'}               
            )               
            1. /正则/               
                db.stu.find(                   
                    {name:/黄/}               
                )               
            2.{$regex:"正则"}               
                db.stu.find(                   
                    {                       
                        name:{$regex:"段"}                   
                    }               
                )                                           
            3. 忽略大小写               
                3.1 db.stu.find({name:/lily/i})               
                3.2 db.stu.find(                   
                    {                       
                        name:{$regex:"lcf",                            
                        $options:"i"}                   
                    }               
                )            
        }        
        6.自定义函数  $where         
            db.xx.find(             
                {             
                    $where:带返回值的 匿名函数             
                }         
            )            
            //取年龄 大于20岁的人  age > 20            
            db.stu.find(                
                {                    
                    $where:function () {                        
                        return this.age > 20                    
                    }                
                }            
            )
6.查询结果显示       
    1.skip 跳过几个显示       
    2.limit 允许显示几个            
        //跳过两个 显示4个                    
        注意点:  没有顺序之分            
        db.stu.find().skip(2).limit(4)>            
        db.stu.find().limit(4).skip(2)                  
    3.投影 显示哪些字段; 显示 true  不显示false            
        db.xx.find(                
            {查询条件},                
            {字段:true}            
        )       
    4.sort 排序:  -1降序 1 升序            
        // 年龄 排降序, 相同的按照id 降序            
        db.stu.find().sort({age:-1,_id:-1})       
    5.count 统计个数                   
        //统计所有          
        db.xx.count()        
        //   根据条件              
    6.distinct 去重           
        // 取出年龄 小于 60岁的; 籍贯          
        db.xx.distinct("去重字段",{查询条件})          
        db.stu.distinct(              
            "hometown",{}          
        )    
7.聚合查询:          
    // 管道有顺序        
    db.xx.aggregate(            
        [                
            {管道1},                
            {管道2},                
            {管道3}            
        ]        
    )                               
    // 多条件的 多件事                            
    $group: 分组                
    // 数据按照 gender性别分组                
    db.stu.aggregate(                    
        [                        
            {$group:{_id:"$gender"}}                    
        ]                
    )                
    db.stu.aggregate(                    
        {$group:{_id:"$hometown"}}                
    )                               
    // 表达式: $sum $avg $first $last $max $min  $push                
    // 数据按照 性别分组 求年龄的平均值                              
    db.stu.aggregate(                    
        {$group:                        
            {                            
                id:"$gender",avg_age:{$avg:"$age"}                       
            }                    
        }                
    )                
    // 按照籍贯分组, 求年龄和                
    db.stu.aggregate(                    
        {$group:                        
            {                            
                _id:"$hometown",sum_age:{$sum:"$age"}                        
            }                    
        }                
    )                           
    // $push  将分组想取出来的数据 放入到一个列表                
    //  取出 按照性别分组的 所有人的名字                
    db.stu.aggregate(                    
        {$group:{_id:"$gender",all_name:{$push:"$name"}}}                
    )                                                      
    $match: 查找符合条件的数据 ; find 区别                    
    // 查询功能一样                    
    // match可以配合管道使用的                   
    // 取出年龄大于20人                   
    db.stu.find({age:20})                   
    db.stu.aggregate(                       
        {$match:{age:20}}                   
    )                                     
    // 取出年龄小于40的; 按照性别分组求年龄平均值($avg)                   
    db.stu.aggregate(                       
        {$match:{age:{$lt:40}}},                       
        {                           
            $group:{_id:"$gender",avg_age:{$avg:"$age"}}                       
        }                   
    )                                    
    $project:投影取出部分字段; 显示1                     
    // 取出年龄大于20; 按照籍贯分组 求出年龄之和,求年龄平均值; 查看的时候只想看到之和                  db.stu.aggregate(                      
        {$match:{age:{$gt:20}}},                      {$group:{_id:"$hometown",sum_age:{$sum:"$age"},avg_age:{$avg:"$age"}}},                      {$project:{sum_age:1}}                                          
    )                                                    
    //    {$project:{_id:1,age_sum:0}} 错误演示                
    //    db.stu.aggregate(                
    //     {$group:{_id:"$hometown", age_sum:{$sum:"$age"},age_avg:{$avg:"$age"}}},                
    //     {$project:{_id:0,age_avg:0}}                
    //    )
    $sort: 排序 1升序 -1降序                   
    //先找 45以下 ;再安籍贯分组 求平均值, 在降序, 在投影
    db.stu.aggregate(                       
        {$match:{age:{$lt:45}}},                       
        {$group:{_id:"$hometown",avg_age:{$avg:"$age"}}},                       {$sort:{avg_age:-1}}                                          
    )                                                       
    //注意点: 管道是有顺序的 不能随意颠倒; 根据需求            
    $skip  跳过几个查看            
    $limit 允许显示几个                   
    //先跳2个 在显示 4个                   
    db.stu.aggregate(                       
        {$skip:2},                       
        {$limit:4}                   
    )                   
    db.stu.aggregate(                    
        {$limit:4},                    
        {$skip:2}                                   
    )                                    
    $unwind :将数据列表 分割  拆分                  
    //按照性别分组, 求出人的名字 $push
    
    // 按照标准写法 书写 [ ]               
    db.stu.aggregate(                    
        [                        
            {                            
                $group:{                                
                    _id:"$gender",                                
                    all_name:{$push:"$name"}                            
                }                        
            },                        
            {                            
                $unwind:"$all_name"                        
            }                    
        ]                
    )
8.MongoDB的索引操作       
    1. 创建批量的数据 20W 的数据       
        for (let index = 0; index < 200000; index++) {                     
            db.stu.insert(               
                {                   
                    _id:index,                  
                    name:"name"+index,                   
                    age:index               
                }           
            )       
        }                     
        2. 查看 数据的时间 对比 毫秒       
            db.xx.find().explain('executionStats')       
            2.1 查看 _id   1毫秒       
                db.stu.find({_id:66666}).explain('executionStats')       
            2.2 查看 name  148毫秒       
                db.stu.find({name:"name66666"}).explain('executionStats')       
            2.3 查看 age   123毫秒       
                db.stu.find({age:66666}).explain('executionStats')                                     
        3. 设置 ID索引ensureIndex       
            db.stu.ensureIndex({name:1})       
            查询 所有的索引       
            db.stu.getIndexes()       
        4. 删除 自定义的索引       
            db.stu.dropIndex('')                
9.MongoDB的备份和恢复             
    mongodump -h 127.0.0.1:27017 -d dumpdb -o /Users/lpf/Desktop/new/       
    备份: mongodump -h -d -o        
    -h: host "IP:port"        
    -d: 备份的数据库名字 db        
    -o: 备份到哪里去       
    mongorestore -h 127.0.0.1:27017 -d newdump --dir /Users/lpf/Desktop/new/dumpdb        
    恢复: mongorestore -h -d --dir        
    -h: host        
    -d: 恢复的数据的名字        
    --dir :从哪里恢复        
10 数据的导出和导入    
    mongoexport -h dbhost -d dbname -c colname -o filename --type json/csv -f field         
    mongoexport -h 127.0.0.1:27017 -d stu -c stu -o data.json     
    mongoexport -h 127.0.0.1:27017 -d stu -c stu -o data.csv --type csv -f _id,name,age,gender    
    -h: 服务器地址    
    -d: 数据库名    
    -c: 集合名    
    -o: 导出文件名    
    --type: 文件类型，默认json格式，可选数据类型json，csv    
    -f: 需要导出的字段,导出为json格式的数据时可以不指定导出哪些字段，默认全部，导出成csv文件是必须指定
    
    示例：mongoexport -h 192.168.196.128:27017 -d test2 -c col1 -o test1_col1 [--type csv -f name,age,number]    
    mongoexport -h "127.0.0.1:27017" -d stu -c stu -o test.json --type json         
    导入    
    mongoimport -d dbname -c collectionname --file filename --headerline --type json/csv -f field        
    mongoimport -d new -c ABC --file ./data.json     
    mongoimport -d new -c person --file ./data.csv --headerline --type csv    
    -d ：数据库名    
    -c ：collection名    
    --type ：导入的格式默认json    
    -f ：导入的字段名    
    --headerline ：如果导入的格式是csv，则可以使用第一行的标题作为导入的字段    
    --file ：要导入的文件            
    
10.python和MongoDB的交互       
    1.建立链接       
    2.创建库       
    3.创建集合       
    4.插入数据