看完我的笔记不懂也会懂----MongoDB

• MongoDb数据库学习
  
  - 数据库的分类
  
  - 数据库基本概念
  
  - MongoDB常用指令
  
  - MongoDB的CURD
  
  - sort({key:*[1,-1]})、limit(num)、skip(num)
  
  - find()方法之投影
  
  - Mongoose
  
  - mongoose使用
  
  - Mongoose增删改查
  
  - Mongoose之Document

MongoDb数据库学习

数据库的分类

• 关系型数据库(RDBMS)
  • 数据结构都是表
  • 例如:MySQL、Oracle、DB2、SQL Server
• 非关系型数据库(NO SQL)
  • 键值对数据库
  • 文档数据库

MongoDB属于非关系型数据库中的文档数据库

数据库基本概念

• 数据库(database)
• 集合(collection)
• 文档(mongodb中的最小单位)

MongoDB常用指令

show dbs/databases  查看数据库
use 数据库名         切换到指定的数据库中(数据库可以不存在,如果不存在会在第一次向其中写入数据时创建)
db                  查看当前所在的数据库
show collections    显示数据库中所有的集合
<colletions>.drop() 删除整个集合
dropDatabases(<databases>) 删除整个数据库

MongoDB的CURD

//切换到数据库
use mydb    //存在就切换到，不存在会在第一次写入数据时创建

//Create  增    db.<collections>.insert({attr:value});
//向  mydb(数据库)中  的  data集合中  插入phone文档
db.data.insert({phone:13266032311});    //此时db是mydb
db.data.insert([{phone:13266032311},{test:'ok'}]);    //此时db是mydb
//一次性只能插入一个
db.data.insertOne({phone:15362994569});    //此时db是mydb
//一次性只能插入多个(插入一个数组里面有多个文档)
db.data.insertMany([{phone:15362994569},{phone:15362994569}]);    //此时db是mydb

//Retrieve  查      db.<collections>.find({att:value})
db.data.find();     //查询所有文档
db.data.find({});   //查询所有文档
db.data.find({name:"Fitz"});   //查询name为Fitz的文档
db.data.findOne()   //查询符合条件的一个文档
//find()返回的是一个数组(数组里面的元素是文档),findOne()返回是一个文档
//所以find()[0] === findOne()

//返回文档长度
db.data.find().count();
db.data.find().length();

//update    改      db.<collections>.update/updateMany/updateOne({oldAttr:oldValue},{newAtt:newValue})
//直接将符合条件的对象完全替换为新对象
db.data.update({name:"wenda"},{name:"CLXXX",age:20})
db.data.replaceOne({name:"wenda"},{name:"CLXXX",age:20})

//修改指定属性
db.data.update(
    {_id:ObjectId("5f4f64c6bf15e4118fcf7c2d")},    //找到指定对象
    {$set:
        {chinese:"English",name:"Been modified",age:"ddd"}  //key为指定属性,value是新值
    }
)

//update默认只会修改第一个，需要updateMany修改符合条件的多个文档
db.data.update(
    {_id:ObjectId("5f4f64c6bf15e4118fcf7c2d")},    //找到指定对象
    {
        $set:
        {aaa:"changeALL"}
    },
    {
        //修改多个文档的属性
        multi:true      //将所有符合条件(有aaa属性)的文档的aaa属性的值修改为changeALL
    }
)

//updateOne()
db.data.updateOne(
{name:"test",gender:"fff"},
    {$set:
        {gender:"newGender"}
    }
)

//Delete  删    db.collection.remove()/deleteOne()/deleteMany()
//remove默认会删除符合条件的所有文档    注意:update默认只会修改一个
db.data.remove({_id:ObjectId("5f4f43b3bf15e4118fcf7c28")})  //删除id为...的文档
//让remove只删除符合条件的一个文档
db.data.remove({_id:ObjectId("5f4f43b3bf15e4118fcf7c28")},true)  //删除id为...的文档
// **删除集合中的所有文档
db.data.remove({})

sort({key:*[1,-1]})、limit(num)、skip(num)

这三个方法能够以任意顺序使用

//找到user值为fitz的文档，根据user值的升序显示
db.data.find(
    {user:"fitz"}
).sort({user:1})

//找到所有文档，但是最多只显示10条文档
db.data.find({}).limit(10)

//找到符合条件的文档(这里是所有文档),显示下一个能够显示的最大值(这里是20)
db.data.find({}).limit(10).skip(1)

find()方法之投影

利用find()方法的第二参数，可以使用投影，投影的作用是可以只显示我们想看到数据

//查找当前数据库中  data集合中  user值为fitz的文档   只显示这些文档的age值，并且以升序呈现
db.data.find(
    {user:"fitz"},
    {age:1}     //1升序   -1降序
)

Mongoose

mongoose提供了schema能够较好的操作MongoDB

mongoose中为我们提供了几个新的对象

1. Schema(模式对象)
   1. Schema对象定义约束了数据库中的文档结构

   //创建schema对象
   var Schema = mongoose.Schema;   //这一步作用是简化后面书写
   var stuSchema = new Schema({
       name:String,
       age:Number,
       gender:{
           type:String,
           default:'Male'
       },
       address:String
   })
   

2. Model对象
   1. 相当于MongoDB中的collection集合

   //通过schema创建model
   //model相当于数据库中的集合collection
   
   //mongoose.model(modelName,schema)
   //modelName是姚应社的集合名
   //schema是第一步创建的schema约束
   var StuModel = mongoose.model('student',stuSchema)
   
   //创建一个文档并将其插入到数据库中
   StuModel.create({
       name: 'Fitz',
       age: 20,
       gender: 'Female',
       address: 'Chenwu'
   },function(error){
       if(error){
           console.log(error);
       }else{
           console.log('插入成功');
       }
   })
   

3. Document对象
   1. 相当于MongoDB中集合中的文档(每个数据)
   2. Document对象是Model是实例

   //document对象是Model是实例
   console.log(docs[0].__proto__ === StuModel.prototype);  //true
   console.log(docs[0] instanceof StuModel.prototype);     //true
   

mongoose使用

连接/断开数据库

//引入mongoose对象
var mongoose = require("mongoose");
//连接MongoDB数据库
mongoose.connect('mongodb://127.0.0.1:27017/mongoose_test')

//监听数据库连接事件
mongoose.connection.once('open',function(){
    console.log('connect success');
})

//监听数据库断开事件
mongoose.connection.once('close',function(){
    console.log('数据库已断开');
})

//断开数据库连接
//mongoose.disconnect()

Mongoose增删改查

增(Create)

//Model.create(content,[callback])
StuModel.create([
    {
        name:'1',
        age:10,
        gender:'male',
        address:'one'
    },
    {
        name:'2',
        age:20,
        gender:'Female',
        address:'two'
    },
])

删(Delete)

/*
*  Model.remove(conditions,[callback])
*  Model.deleteOne(conditions,[callback])
*  Model.deleteMany(conditions,[callback])
* */
StuModel.remove(
    {name:1},
    function(e,info){
        if(e){
            console.log(e);
        }
        console.log(info);
    }
)

改(Update)

/*
*   Model.update(conditions,doc,[options],[callback])
*   Model.updateOne(conditions,doc,[options],[callback])
*   Model.updateMany(conditions,doc,[options],[callback])
* */
StuModel.update(
    {name: 2},
    {$set:
            {
                name: 'nameChange',
                address: 'addressChange'
            }
    },
    function(e,info){
        if(e){
            console.log('ERROR: ' + e);
        }
        console.log(info);
    }
)

StuModel.updateOne(
    {name: 2},
    {$set:
            {
                name: 'nameChange',
            }
    },
    function(e,info){
        if(e){
            console.log('ERROR: ' + e);
        }
        console.log(info);
    }
)

查(Retrieve)

/*
*  Model.find(conditions,[projection],[options],[callback])     符合条件的所有文档
*  Model.findById(id,[projection],[options],[callback])     根据id查找
*  Model.findOne([conditions],[projection],[options],[callback])    查找符合条件的第一个文档
*  Model.count([conditions],[callback])    查找符合条件的文档数量
*
*    conditions  条件
*    projection  条件
*    options     查询选项(skip、limit)
*    callback    查询结果通过回调函数返回
*/

StuModel.find(
    //第一个参数  查询条件
    {
        //name: 'Fitz'
    },

    //第二个参数  投影
    //设置投影  方式一
    'address -_id', //不需要显示的用-

    //设置投影  方式二
    /*{
        address:1
    },*/

    //第三个参数   选项
    {skip:2,limit:1},

    //第四个参数  回调函数
    function(error,docs){
        console.log(docs);  //结果返回一个    包含文档对象  的     数组
    }
)

//数据统计
StuModel.count({},function(e,countNum){
    if(e){
        console.log(e)
    }else{
        console.log(countNum)
    }
})

Mongoose之Document

Document 和 集合中的文档一一对应，

创建Document

//var doc = new Model({})
var stu = new StuModel({
    name:'newStu',
    age:40,
    gender:'male',
    address:'DG'
})

修改Document

StuModel.findOne({},function(e,doc){
    console.log(doc);
    //方法一
    doc.update(
        {
            $set:{
                gender:'male'
            }
        },
        function(e){
            if(!e){
                console.log('修改成功');
            }
        }
    )

    //方法二
    doc.address = 'ChenWu'
    doc.save()

    console.log('修改后结果==>' + doc);
})

删除Document

StuModel.findOne({},function(e,doc){
    doc.remove(function(){
        console.log('成功删除');
    })
})

获取Document的属性值

StuModel.findOne({},function(e,doc){
    var result = doc.get('name')
    console.log(result)
})

设置Document的属性值

StuModel.findOne({},function(e,doc){
    doc.set('address':'China')
    doc.save()
})