MongoDB数据库的基本操作

1.MongoDB的启动
1.启动服务:
sudo mongod
2.启动客户端
mongo

2.数据库的操作:
1.查看默认的数据库 db
2.查看所有的数据库 show dbs
3.查看所有的集合(表) show collections
4.查看集合中的文档(行) db.xx.find()
5.删除数据库 先进入,再db.dropDatabase()

3.集合(表)的操作:
1.查看所有的集合 show collections
2.创建集合 db.createCollection(“集合名字”)
3.删除集合 db.xx.drop()
4.文档内容的增删改:
1.数据的类型
null
integer
Double
object
timestamps
Date Date(2017-01-01)
ObjectID:1,2,3,4 1.系统自动生成 2.手动指定
string
boolean
Array
2.增加数据:
db.xx.insert({key:Value})

        //1.新增一条数据
           db.one.insert(
                {
                _id:1,
                name:"张三",
                age:28  
                }
            )
            db.one.insert(
                {
                name:"老王",
                age:88  
                }
            )
        //2.先字典 后赋值
            dict = {
                _id:2,
                name:"小王吧",
                age:18  
            }
            db.one.insert(dict)
    3.删除
        db.xx.remove({条件})

        //1.删除老王 
            db.one.remove({name:"老王"})
        //2.删除所有的男生(默认 符合条件的都删除)
            db.one.remove({gender:true})
        //3. 只删除 符合条件的 第一个 justOne
            db.one.remove({gender:false},{justOne:true})
        //4.全部删除数据
            db.one.remove({})
    4.改 update
            db.xx.update({查找条件},{修改内容})

            //1.修改 小明 的名字 根据id
                //2. like
                //默认 其他的字段删除了
                db.one.update({_id:4},{name:"大明"})
                db.one.update({_id:5},{like:"男朋友"})

            //2.只想修改指定的字段; 其他的不变$set
                db.one.update({_id:7},{$set:{name:"霜霜"}})

            //3. 默认符合条件的只修改一个;全部修改 multi

                //男生的年龄 改成 30谁
                db.one.update(
                    {gender:true},
                    {$set:{age:30}}
                )
                //将女生的年龄 全部修改成 12岁
                db.one.update(
                    {gender:false},
                    {$set:{age:12}},
                    {multi:true}
                )

5.文档的基本查询操作:
1.基本查询
db.xx.find({查找条件}).pretty()

            1.1: db.xx.find() 查找所有的内容
            1.2: 查找所有的女生:返回所有符合条件的内容
                db.stu.find({gender:false})
            1.3:只返回符合条件的第一个
                db.stu.findOne({gender:true})
    2.条件运算: $lt $gt $lte $ne
            db.xx.find({字段:{运算符:值}})

            //1.筛选年龄大于20岁的人
                db.stu.find(
                    {
                        age:{$gt:20}
                    }
                )
            //2.筛选年龄 小于等于18岁的
                db.stu.find(
                    {
                        age:{$lte:18}
                    }
                )
            //3. 年龄不等于 45岁
                db.stu.find(
                    {
                        age:{$ne:45}
                    }
                )
    3.逻辑运算: $and $or
            db.xx.find({运算符:[{条件1},{条件1}]})

            1. $and 其实find默认多条件就是and
                db.stu.find(
                    {age:16,gender:true}
                )
                db.stu.find(
                    {
                        $and:[
                            {age:16},
                            {gender:true}
                        ]
                    }
                )
             // 年龄大于20; 男生
               db.stu.find(
                   {
                       $and:[
                           {age:{$gt:20}},
                           {gender:true}
                       ]
                   }
               )

            2. $or 
               // 年龄大约20岁,或者false 女生
               db.stu.find(
                   {
                       $or:[
                           {age:{$gt:20}},
                           {gender:false}
                       ]
                   }
               )

            3. $and 和 $or 混用的关系
              // 年龄下雨45岁或者是女生; 必须是来自桃花岛
              db.stu.find(
                  {
                      $ang:[
                          {$or:[
                               {age:{$lt:45}},
                                {gender:false}
                                ]
                            },
                          {hometown:"桃花岛"}
                      ]
                  }
              )

              // 来自蒙古或者是大理的人  要求必须是男士
              db.stu.find({$and:[{$or:[{hometown:"蒙古"},{hometown:"大理"}]},{gender:true}]})

    4.范围运算:$in  $nin
              db.xx.find({字段:{运算符:[值]}})
              //1. 18 20 40的岁
              db.stu.find(
                  {
                      age:{$in:[18,20,40]}
                  }
              )
              //2. 来自 大理 或者  蒙古
              db.stu.find(
                  {hometown:{$in:["大理","蒙古"]}}
              )
    5.正则表达式:
              1.db.xx.find({字段:/正则/})
              2.db.xx.find({字段:{$regex:"正则"}})

              //1. 段
              db.stu.find({name:/段/})
              db.stu.find({name:/liu/i})
              db.stu.find(
                  {
                      name:{$regex:"段"}
                  }
              )

              //2. 忽略大小写 $options
              db.stu.find(
                  {
                      name:{$regex:"liu",$options:"i"}
                  }
              )
    6.自定义函数:

            db.xx.find({$where:待返回值的匿名函数})
            //年龄小于 18的人
            //this 操作的内容
            db.stu.find(
                {
                    $where:function () {
                        return this.age < 18
                    }
                }
            )

6.查询结果的显示:
skip(n): 跳过几个在显示
limit(n): 允许显示几个

            db.stu.find().skip(2).limit(3)
            如果 skip和limit混用 结果一样的
    投影: 允许查看的字段
          db.xx.find({查询条件},{投影的条件字段:1})
          db.stu.find({gender:false},{_id:1})
    排序: 升序 1  降序 -1 sort({字段:1})
         db.stu.find().sort({age:-1,_id:-1})
    统计:count()
         db.xx.count({条件})
         db.xx.find().count()

         db.stu.count({age:{$gt:30}})
         db.stu.find({age:{$gt:30}}).count()
    去重:distinct()
        db.xx.distinct("去重的字段",{条件})
        // 取出年龄小于60岁一下 人的籍贯
        db.stu.distinct("hometown",{age:{$lt:60}})

7.python和MongoDB 的交互

            1. 127.0.0.1
            2. 27017
            3.连接数据库 客户端
            4. 根据客户端 创建数据库
            5. 创建集合
            6. 写入数据

MongoDB ——— 第二天
1.聚合查询:管道
db.xx.aggregate([{管道1},{管道2},{管道3}])

   $group: 分组:
            db.xx.aggregate([{$group:{_id:"$字段"}}])

            // 将数据  按照 性别分成两种组
            db.stu.aggregate(
                [
                    {$group:{_id:"$gender"}}
                ]
            )
            //按照性别分组 ,求出每组的年龄平均值 表达式
             // $avg $sum $max $min $last $first $push
            db.stu.aggregate(
                {
                    $group:{_id:"$gender",age_avg:{$avg:"$age"}}
                }
            )

            // 按照籍贯分组 求每个地方人的年龄之和
            db.stu.aggregate(
                {
                    $group:{_id:"$hometown",age_sum:{$sum:"$age"}}
                }
            )

            // 按照 性别分组; 想求出 最后一个人的年龄
            db.stu.aggregate(
                {
                    $group:{_id:"$gender",last_age:{$last:"$age"}}
                }
            )

            db.stu.aggregate(
                {
                    $group:{_id:"$gender",first_age:{$first:"$age"}}
                }
            )

            db.stu.aggregate(
                {
                    $group:{_id:"$hometown",max_age:{$max:"$age"}}
                }
            )

            //push 将获取的字段 按照分组 显示
            //按照性别分组 , 求出 每组的籍贯有哪些
            db.stu.aggregate(
                {
                    $group:{_id:"$gender",address:{$push:"$name"}}
                }
            )


   $match: 比较对比 和find功能一致; 区别在于使用管道
            db.xx.find({条件})
            db.xx.aggregate({$match:{比较的条件}})

            // 求出 年龄大于18岁的人
            db.stu.find({age:{$gt:18}})
            db.stu.aggregate({$match:{age:{$gt:18}}})

            // 求出 年龄小于40岁; 按照性别分组 两组
            db.stu.aggregate(
                {$match:{age:{$lt:40}}},
                {$group:{_id:"$gender",name_list:{$push:"$name"}}}
            )

   $project: 投影 :允许查看某个字段
            db.xx.aggregate({$project:{字段:1,自段:0}})

            //1. 求出年龄不等于18; 按照性别分组求出name;只显示名字
            db.stu.aggregate(
                {$match:{age:{$ne:20}}},
                {$group:{_id:"$gender",all_name:{$push:"$name"}}},
                {$project:{_id:0,all_name:1}}
            )

   $sort: 排序 1 升序 -1降序
           //1.按照籍贯 来自 大理和桃花岛;一 年龄降序
            db.stu.aggregate(
                {$match:{hometown:{$in:["大理","桃花岛"]}}},
                {$sort:{age:-1}}
            )
   $limit: 允许显示几个
   $skip: 跳过几个查看
         注意点: 因为管道是有先后顺序; 所以呢一般都不掉换顺序; 先跳后允许查看几个
          //先找 45以下 ;再 安籍贯 求平均值, 在 降序, 在投影
          db.stu.aggregate(
              {$match:{age:{$lte:45}}},
              {$group:{_id:"$hometown",avg_age:{$avg:"$age"}}},
              {$sort:{avg_age:-1}},
              {$project:{_id:1,avg_age:1}},
              {$skip:1},
              {$limit:2} 
          )

   $unwind: 将一组 列表的数据 分开成多个文档 
          // 筛选 安性别分两组;  求出每组人的名字
          db.stu.aggregate(
              {$group:{_id:"$gender",all_name:{$push:"$name"}}},
              {$unwind:"$all_name"}
          )

2.索引操作 : 通过索引查询 效率最高 时间
2.1 批量的创建数据
for (index = 0; index < 200000; index++) {
db.stu.insert(
{
_id:index,
name:”name”+index,
age:index
}
)
}

    2.2 时间查询时间 
     //1.通过 字段的内容查找 --executionTimeMillis 119毫秒
        db.stu.find({name:"name199999"}).explain("executionStats")

    //2. 通过索引查找 time 1毫秒
        db.stu.find({_id:199999}).explain("executionStats")

    //3. 系统自己分配id 记不住
         // 3.1 自定义索引
        db.stu.ensureIndex({name:1})
        db.stu.ensureIndex({age:1})

        //3.2 查看所有的 索引
        db.stu.getIndexes()

        //3.3 删除索引
        db.stu.dropIndex("name_1")

3.备份和恢复
-h IP:port
-d 数据库的名字
-o 备份到的地址
–dir 从哪里恢复
备份:sudo mongodump -h 192.168.101.33:27017 -d stu -o ~/Desktop/save/
恢复:sudo mongorestore -h 127.0.0.1:27017 -d stu –dir ~/Desktop/save/stu