MongoDB & Mongoose对象模型 - 数据库笔记

274 阅读14分钟

@TOC

数据库介绍分类

数据库(Database)

  • 我们的程序都是在内存中运行的,一旦程序运行结束或者计算机断电,程序运行中的数据都会丢失。
  • 数据库是按照数据结构来组织、存储和管理数据的仓库。数据库就是存储数据的仓库。
  • 数据库分类 - SQL 结构化查询语言
    • 数据库主要分成两种:
      • 关系型数据库(RDBMS) ● MySQLOracleDB2 SQL Server ... ● 关系数据库中全都是表
      • 非关系型数据库(No SQL Not Olny SQL) ● MongoDBRedis ... ● 键值对数据库 ●文档数据库 MongoDB

MongoDB简介 下载

  • MongoDB是为快速开发互联网Web应用而设计的数据库系统。

  • MongoDB的设计目标是极简、灵活、作为Web应用栈的一部分。

  • MongoDB的数据模型是面向文档的,所谓文档是一种类似于JSON的结构,简单理解MongoDB这个数据库中存的是各种各样的JSON。( BSON )

  • 下载MongoDB

    • MongoDB下载链接1 --- MongoDB下载链接2 ● MongoDB的版本偶数版本为 稳定版 , 奇数版 本为开发版。 ●MongoDB对于32位系统支持不佳,所以3.2版本以后没有再对32位系统的支持。

安装MongoDB

SQL -结构化查询语言- 关系数据库全都同sQL来操作

  1. 安装MongoDB
  2. 配置环境变量
    • C: \Program Fi les \MongoDB\Server\3.2\bin
  3. 创建数据库的存放的路径:在c盘根目录或自定义
    • 创建一个文件夹data
    • 在data中创建一个 文件夹db
    • 自定义路径:mongod --dbpath C:\Users\Desktop\data\db --port 10086 -->: C:\Users\Desktop\data\db (数据库路径) --port 端口号(建议:10086 以上,65535 以下-默认是27017
  4. 打开cmd命令行窗口,不要关闭
    • 输入mongod启动 mongodb服务器
    • 32位注意:第一次启动服务器时,需要输入如下内容:mongod --storageEngine=mmapv1 以后就可以 mongod 启动
  5. 再打开一个cmd窗口
    • 输入mongo 客户端连接mongodb,出现 > 以成功连接
  • 数据库(database)
    • 数据库的服务器
      • 服务器用来保存数据
      • mongod 启动服务器
    • 数据库的客户端
      • 客户端用来操作服务器,对数据进行增删改查的操作
      • mongo 启动客户端

把MongoDB设置为系统服务,自动后台启动服务

参考网站:MongoDB服务器设置-- 注意 4.0版本以后MongoDB会自动设置服务(去服务开启MongoDB)-(启动mongodb的服务,提示Windows无法启动MongoDB Server服务(位于本地计算机上)..)-->服务器启动失败解决方法

	- 将MongoDB 3.0 设置为系统服务,可以自动在后台启动,不需要每次都手动启动
		1.在c盘根目录创建data
			- 在data下创建db和log文件夹
		2.创建配置文件
			在目录 C:\Program Files\MongoDB\Server\3.2 下添加一个配置文件
			mongod.cfg
		3.以管理员的身份打开命令行窗口	
		
		4.执行如下的命令
			sc.exe create MongoDB binPath= "\"C:\Program Files\MongoDB\Server\3.2\bin\mongod.exe\" --service --config=\"C:\Program Files\MongoDB\Server\3.2\mongod.cfg\"" DisplayName= "MongoDB" start= "auto"
			
			sc.exe create MongoDB binPath= "\"mongod的bin目录\mongod.exe\" --service --config=\"mongo的安装目录\mongod.cfg\"" DisplayName= "MongoDB" start= "auto"
			
		5.启动mongodb服务

		6.如果启动失败,证明上边的操作有误,
			在控制台输入 sc delete MongoDB 删除之前配置的服务
			然后从第一步再来一次

三个概念

  • 数据库( database )
    • 数据库是-个仓库,在仓库中可以存放集合。
  • 集合( collection )
    • 集合类似于数组,在集合中可以存放文档。
  • 文档( document )
    • 文档数据库中的最小单位,我们存储和操作的内容都是文档。
    • 在MongoDB中,数据库和集合都不需要手动创建
      • 当创建文档时,如果文档所在的集合和数据库不存在则会自动创建数据库和集合

图形化界面安装

链接:MongoDB图形化

基本指令

  • show dbs - 显示当前的所有数据库
  • show databases - 显示当前的所有数据库
  • use 数据库名 - 进入数据库
  • db - 显示当前所处的数据库
  • show collections - 显示数据库所有的集合
  • limit() 设置显示数据的上限
  • sort() 可以用来指定文档的排序的规则,sort()需要传递一个对象来指定排序规则 1表示升序 -1表示降序

数据库的CRUD(增删改查)的操作

向数据库中插入文档

  • db.<collection>.insert(document) - 向集合中插入一个文档
    • 例子:向 test 数据库中的,stus集合中插入一个新的学生对象 {"name" :"孙悟空","age":"18",'sex":"男"}
    • db.stus.insert({"name" :"孙悟空","age":"18",'sex":"男"});
  • db.collection.insertOen(); - - 插入一个文档对象 意思更明确
  • db.collection.insertMany(); - 插入多个文档对象 意思更明确
  • db.collection.find(); - 查询所有集合中符合条件的文档 返回的是一个数组 可以用索引号得到需要的文档
  • db.collection.find().limit(10) --.limit() 设置显示数据的上限
  • db.collection.find({}).sort({sal:-1,empno:-1}); -sort() 可以用来指定文档的排序的规则,sort()需要传递一个对象来指定排序规则 1表示升序 -1表示降序
  • db.collection.find({},{ename:1,_id:0,sal:1}); -在查询时,可以在第二个参数的位置来设置查询结果的 投影 1 表示投影(显示)到屏幕上 0 表示不投影(不显示)
  • db.collection.find({}).count(); - 可以得到所有结果的长度
  • db.collection.findOne(); 查询第一个符合条件的文档 返回的是一个对象 可以利用对象属性的方法进行访问
  • db.collection.update(查询条件,新对象); - update() 默认情况下会使用新对象来替换旧的对象 详细看下面修改案例有$set$unset
  • db.collection.updateMany() - 同时修改多个符合条件的文档
  • db.collection.updateOne(); - 修改第一个符合条件的文档
  • db.collection.remove() - - 删除符合条件的所有文档(默认删除多个)-remove() 的第二个参数传递一个 true ,则只会删除一个
  • db.collection.deleteOne() - 删除第一符合条件的文档
  • db.collection,deleteMany() - 可以根据条件来删除文档传递的条件的方式和find() 一样
  • db.collection.drop(); - 删除一个集合
  • db.dropDatabase() - 删除数据库

数据运算操作符

比较

  • $eq 匹配等于指定值的值。
  • $gt 匹配大于指定值的值。
  • $gte 匹配大于或等于指定值的值。
  • $in 匹配阵列中指定的任何值。
  • $lt 匹配小于指定值的值。
  • $lte 匹配小于或等于指定值的值。
  • $ne 匹配所有不等于指定值的值。
  • $nin 与数组中指定的值不匹配。

逻辑

  • $and 将查询条款与逻辑返回加入所有符合两个条款条件的文件。AND
  • $inc 在原来的基础上自增值
  • $not 倒置查询表达式的效果,并返回与查询表达不匹配的文档。
  • $nor 将查询条款与逻辑返回一起,返回所有不能匹配这两个条款的文档。NOR
  • $or 将查询条款与符合任一条款条件的所有文档加入逻辑返回。OR (相当于或者 | 的意思)

元素

  • $exists 匹配具有指定字段的文档。
  • $type 如果字段为指定类型,请选择文档。

评估

  • $expr 允许在查询语言中使用聚合表达式。
  • $jsonSchema 验证针对给定 JSON Schema 的文件。
  • $mod 对字段值执行模组操作,并选择具有指定结果的文档。
  • $regex 选择值与指定的常规表达式匹配的文档。
  • $text 执行文本搜索。
  • $where 匹配满足 JavaScript 表达的文档。

CRUD(增删改查)指令案例:

/* 
    向数据库插入 (增加) 文档
        db.<collection>.insert({});
            向集合中插入一个或多个文档。
            向集合中插入文档时,如果没有给文档指定 _id 属性,则数据库会自动为文档添加 _id 
                该属性用来作为文档的唯一标识
            _id 可以自己指定,如果自己指定了数据库就不会再添加了,同时也要确保 -id 的唯一性
        db.collection.insertOen();
            - 插入一个文档对象 意思更明确
        db.collection.insertMany();
            - 插入多个文档对象  意思更明确
*/
// 一个传输
db.stus.insert([{name:"猪八戒",age:"8",sex:"man"}])
// 多个传输 数组
db.stus.insert([
        {name:"蜘蛛精",age:"8",sex:"woman"},
        {name:"白骨精",age:"8",sex:"woman"},
        {name:"沙和尚",age:"68",sex:"man"},
        {name:"猪八戒",age:"58",sex:"man"}
]);
db.stus.find(); // 查找stus集合里的所有文档
ObjectId(); // 创建id号
db.stus.insert([{_id:"hello",name:"猪八戒",age:"8",sex:"man"}]);  // 自定义id号

/*
    查询
        db.collection.find();  
            - find() 用来查询集合中所有符合条件的文档
            - find() 可以接收一个对象作为条件参数
                {} 表示查询集合中的所有文档
                {属性:“值”} 查询属性指定值的文档
            - find() 返回的是一个数组,可以根据索引号得到要的文档
            
        db.stus.findOne();
            - 查询集合中第一个符合条件的文档
            - findOne() 返回的是一个文档对象,可以使用对象属性的方法进行访问
            
        db.stus.find({}).count();       db.stus.find({}).length();
            - .count() 常用  查询所有结果的数量
*/
db.stus.find({_id:"hello"});

db.stus.find({age:'18',name:"lhj"});

db.stus.find({_id:"hello"})[0];

db.stus.findOne({_id:"hello"}).name;

db.stus.find({}).length();

/*
    修改
        - db.collection.update(查询条件,新对象);
            - update() 默认情况下会使用新对象来替换旧的对象 
            - 如果需要修改指定的属性,而不是替换就需要用到修`改操作符`来完成修改
                $set 可以用来修改文档中指定的属性
                $unset 可以用来删除文档指定的属性
            - update() 默认只修改一个
            
        - db.collection.updateMany()
            - 同时修改多个符合条件的文档
            
        - db.collection.updateOne();
            - 修改第一个符合条件的文档
            
        - db.collection.replaceOne()
            - 替换一个符合条件的文档
*/

db.stus.find({});

db.stus.update({name:"白骨精"},{age:"16"});

db.stus.update(
    {"_id" : ObjectId("603f3595a3a28f37045db8cc")}, 
    { $set: {
            adress: "努力"
     }}
);

db.stus.update(
    {"_id" : ObjectId("603f3595a3a28f37045db8cc")}, 
    { $unset: {
            name: "1"
     }}
);

db.stus.updateMany(
    { name: "沙和尚"}, 
    
        { $set: {
                adress: "borwm"
         }
    }
);

// 默认修改一个  添加属性: mulit: true 修改多个
db.stus.update(
    { name: "沙和尚"}, 
    
        { $set: {
                adress: "你好啊"
         }
    },
    {
        multi: true  
    }
);
db.stus.replaceOne({name:"白骨精"},{user:"123"})
db.stus.find({})

 /*
     删除
        db.collection.remove() 
            - 删除符合条件的所有文档(默认删除多个)
                - remove() 的第二个参数传递一个 true ,则只会删除一个
            - 如果只传递一个空对象作为参数,则删除集合中的所有文档
        db.collection.deleteOne()
            - 删除第一符合条件的文档
        db.collection,deleteMany()
            - 可以根据条件来删除文档,传递的条件的方式和find() 一样    
        db.collection.drop(); - 删除一个集合
        db.dropDatabase() - 删除数据库
            - 一般数据库的数据很少删除,所以删除的方法很少调用
                - 一般在数据中添加一个字段,来表示数据是否被删除
 */ 
db.stus.remove({_id:"hello"});
db.stus.remove({sex:"man"},true);
// 清空集合 (性能略差)
db.stus.remove({});
show collections
db.stus.drop();
db.dropDatabase();
db.stus.insert([
    {
        name:"qwe",
        isDel: 0
    }, 
    {
        name:"asd",
        isDel: 0
    }, 
    {
        name:"zxc",
        isDel: 0
    }, 
]);
db.stus.find({isDel:0});

基本指令复习

//1.进入my_test数据库
use my_test
//2.向数据库的user集合中插入一个文档	
show collections
db.users.insert({ name: "lhj", age: 18 });
//3.查询user集合中的文档
db.users.find();
//4.向数据库的user集合中插入一个文档		
db.users.insert({ name: "lyx", age: 18 });
//5.查询数据库user集合中的文档
db.users.find();
//6.统计数据库user集合中的文档数量
db.users.find().count();
//7.查询数据库user集合中username为sunwukong的文档
db.users.find({ name: "lhj" });
//8.向数据库user集合中的username为sunwukong的文档,添加一个address属性,属性值为huaguoshan
db.users.update({ name: "lhj" }, { $set: { adress: "学习" } });
//9.使用{username:"tangseng"} 替换 username 为 zhubajie的文档
db.users.replaceOne({ name: "lhj" }, { name: "LHJ" });
//10.删除username为sunwukong的文档的address属性
db.users.update({ name: "LHJ" }, { $unset: { adress: "" } });
//11.向username为sunwukong的文档中,添加一个hobby:{cities:["beijing","shanghai","shenzhen"] , movies:["sanguo","hero"]}
db.users.update({ name: "LHJ" }, { $set: { hobby: { cities: ["beijing", "shanghai", "shenzhen"], movies: ["sanguo", "hero"] } });

//12.向username为tangseng的文档中,添加一个hobby:{movies:["A Chinese Odyssey","King of comedy"]}
db.users.update({ name: "lyx" }, { $set: { hobby: { movies: ["A Chinese Odyssey", "King of comedy"] } } });
//13.查询喜欢电影hero的文档
// MongoDB支持直接通过内嵌文档的属性进行查询,如果要查询内嵌文档则可以通过(链式) . 的形式来匹配
// 如果通过内嵌文档来对文档进行查询,此时属性名必须加引号
db.users.find("hobby.movies": "hero");
//14.向tangseng中添加一个新的电影Interstellar
// $push 用于向数组中添加一个新的元素
// $addToSet 向数组中添加一个新的元素,如果数组中该元素已存在则不会添加
db.users.update({ name: "lyx" }, { $push{ "hobby.movies": "Interstellar" } });
db.users.update({ name: "lyx" }, { $addToSet{ "hobby.movies": "Interstellar" } });
//15.删除喜欢beijing的用户
db.users.remove({ "hobby.cities": "beijing" });

//16.删除user集合
db.users.remove({});
db.users.drop();
//17.向numbers中插入20000条数据 60s
for (let i = 0; i < 20000; i++) {
    db.users.insert({ num: i });
}
show collections
db.users.find()
db.users.remove({});
// 1.891s
let arr = [];
for (let i = 0; i < 20000; i++) {
    arr.push({ num: i });
}
db.number.insert(arr);
show collections
db.users.find();
//18.查询numbers中num为500的文档
db.number.find({ num: 500 });
//19.查询numbers中num大于5000的文档
db.number.find({ num: { $gt: 5000 } });
//20.查询numbers中num小于30的文档
db.number.find({ num: { $lt: 30 } });
//21.查询numbers中num大于40小于50的文档
db.number.find({ num: { $gte: 40, $lt: 50 } });
//22.查询numbers中num大于19996的文档
db.number.find({ num: { $gt: 19996 } });
//23.查看numbers集合中的前10条数据
db.number.find({ num: { $lte: 10 } });
// limit() 设置显示数据的上限
db.number.find().limit(10);
// 开发时,绝对不会执行不带条件的查询
db.number.find();
//24.查看numbers集合中的第11条到20条数据
/*
    分页  每页显示 10 条 1-10  11-20  21-30 ...
    skip( (页码 - 1) * 每页显示的条数 ).limit(每页显示的条数);
    skip() 用于跳过指定数量的数据
    MongoDB会自动调整 skip 和 limit 的位置
 */
db.number.find().skip(10).limit(10);
//25.查看numbers集合中的第21条到30条数据
db.number.find().skip(20).limit(10);
//26.将dept和emp集合导入到数据库中
db.dept.find();
db.emp.find();
//27.查询工资小于2000的员工
db.emp.find({ sal: { $lt: 2000 } });
//28.查询工资在1000-2000之间的员工
db.emp.find({ sal: { $lte: 2000, $gte: 1000 } });
//29.查询工资小于1000或大于2500的员工
db.emp.find({ $or: [{ sal: { $lte: 1000 } }, { sal: { $gte: 2500 } }] });
//30.查询财务部的所有员工
//    (depno)
let caiwu = db.dept.findOne({dname:"财务部"}).deptno;
db.emp.find({depno:caiwu});

//31.查询销售部的所有员工
let xiaoshou = db.dept.findOne({dname:"销售部"}).deptno;
db.emp.find({depno:xiaoshou});
//32.查询所有mgr为7698的所有员工
db.emp.find({mgr:7698});
db.emp.find();
//33.为所有薪资低于1000的员工增加工资400元
// $inc 在原来的基础上自增值
db.emp.updateMany({sal:{$lte:1000}},{$inc:{sal:400}});

文档之间的关系

/*
    文档之间的关系
        一对一 (one to one)
            - 如:夫妻 (一个丈夫 对应 一个妻子) {}
            - 在MongoDB,可以通过内嵌文档的形式来体现出一对一的关系
            
        一对多 (one to many) / 多对一 (many to one)
            - 如:父母 - 孩子 | 用户 - 订单 | 文章 - 评论
            - 也可以通过内嵌文档来映射一对多的关系   []
        多对多 (many to many)
            - 如:分类 - 商品| 老师 - 学生 | 
*/
// 一对一
db.familyAndHusband.insert([
    {
        name:"lyx",
        husband:{
            name:"lhj"
        }
    },{
        name:"lhj",
        husband: {
            name:"lyx"
        }
    }     
]);

db.familyAndHusband.find();

// 一对多 用户(username) 和 订单(orders)
db.users.insert([
    {
        username:"lhj"
    },{
        username:"lyx"
    }    
]);
db.order.insert({
    list:["巧克力","零食","手机"],
    user_id: ObjectId("6043567cdf680533c4b92935")
    
});
db.users.find();
db.order.find();
db.users.remove({});
// 查询用户lhj的订单
let user_id = db.users.findOne({username:"lyx"})._id;
db.order.find({user_id:user_id});



// 多对多
db.teachers.insert([
    {name:"洪七公"},
    {name:"黄药师"},
    {name:"龟仙人"}
]);

db.stus.insert([
    {
        name:"日本",
        teachers_ids:[
            ObjectId("60435a50df680533c4b92939"), 
            ObjectId("60435a50df680533c4b9293a")
        ]
        
    }, 
    {
        name:"中国",
        teachers_ids:[
            ObjectId("60435a50df680533c4b92939"), 
            ObjectId("60435a50df680533c4b9293a"),
            ObjectId("60435a50df680533c4b9293b"),
        ]
        
    }
]);

db.teachers.find();
db.stus.find();

let gsr = db.teachers.find({name:"龟仙人"})._id;
db.teachers.find({_id:gsr});
db.stus.find({"tearchers_ids.ObjectId":gsr});

Mongoose安装和简介

  • 之前我们都是通过shell来完成对数据库的各种操作的, 在开发中大部分时候我们都需要通过程序来完成对数据库的操作
  • 而Mongoose就是一个让我们可以通过Node来操作MongoDB的模块。
  • Mongoose是一个对象文档模型 ( ODM )库,它对Node原生的MongoDB模块进行了进一步的优化封装,并提供了更多的功能。
  • 在大多数情况下,它被用来把结构化的模式应用到一个MongoDB集合,并提供了验证和类型转换等好处
  • mongoose的好处
    • 可以为文档创建一个模式结构( Schema )
    • 可以对模型中的对象、文档进行验证
    • 数据可以通过类型转换转换为对象模型
    • 可以使用中间件来应用业务逻辑挂钩
    • 比Node原生的MongoDB驱动更容易;

  • 新的对象--mongoose中为我们提供了几个新的对象
  • Schema (模式对象) : Schema对象定义约束了数据库中的文档结构
  • Model : Model对象作为集合中的所有文档的表示,相当于MongoDB数据库中的集合collection
  • Document : Document表示集合中的具体文档,相当于集合中的一个具体的文档

使用

  1. 下载安装Mongoose npm i mongoose --save 2. 在项目中引入 mongoose let mongoose = require("mongoose"); 3. 连接MongoDB数据库 mongoose.connect('mongodb://数据库的ip地址:端口号/数据库名');
    • 如过端口号是默认端口号(27017)则可以省略不写 4. 断开数据库连接(一般不需要使用)
    • MongoDB数据库,一般情况下,只需要连接一次,连接一次以后,除非项目停止服务器关闭,否则连接一般不会断开 mongoose.disconnect();

关键字

  • Model.create(doc(s),[callback]); -用来创建一个或多个文档并添加到数据库中
  • Model.find (conditions, [projection], [options], [callback]) - 查询所有符合条件的文档 总会返回一个数组
  • Model.findById(id, [projection], [options], [callback]) - 根据文档的id属性查询文档 总会返回一个具体的文档对象
  • Model.count(conditions, [callback]) - 统计文档的数量的
  • 通过Schema创建 Model -- Model代表的是数据库中的集合,通过Model才能对数据库进行操作
  • 指令的使用案例里有说明
      - 监听 MongoDB数据库的连接状态
           - 在mongoose对象中,有一个属性叫做connection,该对象表示的是数据库连接。
               通过监听该对象的状态,可以来监听数据库的连接和断开
       监听数据库连接成功的事件
       Mongoose.connection.once("open",function() {});
       监听数据库连接失败的事件
       Mongoose.connection.once("close",function() {});

先有模型对象 --  Schema  再有模型 -- Model   再有文档 -- Document

// 引入mongoose
const mongoose = require("mongoose");
// 连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open",function() {
    console.log("MongoDB数据库已成功连接~~");
});
mongoose.connection.once("close",function() {
    console.log("MongoDB数据库已断开连接~~");
});

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

Mongoose案例

let mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open",function (){
    console.log("demo数据库已经连接成功~~~");
});

//  将 mongoose.Schema 赋值给一个变量 方便操作
let Schema = mongoose.Schema;
// 创建Schema(模式)对象
let stuSchema = new Schema({
    name: String,
    age: Number,
    gender: {
        type: String,
        default : "female"
    },
    address: String,

});

// 通过Schema创建 Model  Model代表的是数据库中的集合,通过Model才能对数据库进行操作
// mongoose.model('modelName',Schema);
// mongooseName 映射的集合名 mongoose会自动将集合的名变成复数

let StuModel = mongoose.model("student",stuSchema);
// 向数据库插入一个文档
StuModel.create({
    name:"白骨精",
    age: 18,
    address:"白骨洞"
},function (err) {
    if(!err) {
        console.log('文档插入成功~~~');
    }else {

    }
});

Model增删查改案例


let mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open",function() {
    console.log("数据库已连接~~");
});
let Schema = mongoose.Schema;
let stuSchema = new Schema({
    name: String,
    age: Number,
    gender: {
        type: String,
        default : "female"
    },
    address: String,

});

let StuModel = mongoose.model("student",stuSchema);
/*
 - 有了Model,就可以来对数据库进行增删改查的操作
   Model.create(doc(s),[callback]);
   - 用来创建一个或多个文档并添加到数据库中
   - 参数:
       - doc(s) 可以是一个文档对象,也可以是一个文档对象的数组
       - callback  当操作完成以后调用的回调函数

   查询的:
        Model.find (conditions, [projection][options][callback])
          - 查询所有符合条件的文档 总会返回一个数组
        Model.findById(id, [projection][options][callback])
          - 根据文档的id属性查询文档   总会返回一个具体的文档对象
        Model.findOne ([conditions][projection][options][callback])
          - 查询符合条件的第一个文档    总会返回一个具体的文档对象
            * conditions 查询的条件
            * projection 投影 需要获取的字段
            *   - 两种方式: 1. {name:1, _id:0} 2. "name -_id"
            * options 查询的选项(skip  limit )
            * callback 回调函数,查询的结果会通过回调函数返回 -回调函数必须传,如果不传回调函数,压根不会查询
       修改:
            Model.update (conditions, doc, [options][callback])
            Model.updateMany (conditions, doc, [options][callback])
            Model.updateOne (conditions, doc, [options][callback])
            * 用来修改一个或多个文档
            * 参数:
                * conditions 查询条件
                * doc 修改后的对象
                * options 配置参数
                * callback 回调函数
             Model.replaceOne(conditions, doc,[options].[callback])

          删除:
            Model.remove (conditions,[callback] )
            Model.deleteOne(conditions,[callback] )
            ModeI.deleteMany(conditions,[callback] )

           Model.count(conditions, [callback])
             - 统计文档的数量的

*/
// 统计算量
StuModel.count({},function(err,count) {
    if(!err) {
        console.log(count);
    }
});

/* 删除
StuModel.remove({_id:"6044760c0ceb0103b4e52e42"},function(err) {
        if(!err) {
            console.log("删除成功~~");
        }
});
*/
/*修改的案例

// 修改年龄
StuModel.updateOne({name:"唐生"},{$set:{age:20}},function (err) {
        if(!err) {
            console.log("修改成功~~");
        }
});

* */

/*  查询的案例
StuModel.findById("604466b612c1690f1040a872",function(err,doc) {
    if(!err) {
        // console.log(doc);
        // 通过find() 查询的结果,返回的对象,就是Document,文档对象
        // Document对象就是Model的实例
        console.log(doc instanceof StuModel);
    }
});
// 返回一个对象
StuModel.findOne({},function(err,doc) {
    if(!err) {
        console.log(doc.name);
    }
});

// 投影:方式二
StuModel.find({},"name age -_id",{skip:3,limit:1},function(err,docs) {
    if(!err) {
        console.log(docs);
    }
});
// 投影:方式一
StuModel.find({},{name:1,_id:0},function(err,docs) {
    if(!err) {
        console.log(docs);
    }
});
// 查询
StuModel.find({name:"唐生"},function(err,docs) {
    if(!err) {
        console.log(docs);
    }
});
*/


/*  插入文档案例
StuModel.create([{
    name:"沙和尚",
    age: 29,
    gender: "male",
    address: "流沙河"
}],function(err) {
        if(!err) {
            console.log(arguments);
        }
});
*/

Document案例

let mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open",function() {
    console.log("数据库已连接~~");
});
let Schema = mongoose.Schema;
let stuSchema = new Schema({
    name: String,
    age: Number,
    gender: {
        type: String,
        default : "female"
    },
    address: String,

});

let StuModel = mongoose.model("student",stuSchema);
/*
   Document 和 集合中的文档一一对应,Document是Model的实例
        通过Model查询到结果都是Document


* */
// 创建一个Document
let stu = new StuModel({
    name:"lyx",
    age:"8",
    gender:"female",
    address:"dc"
});
/*
    document的方法
        Model#save ([options,[options.safe],[options.validateBeforeSave],[fn])
        一般就写: Model#save ([options,[fn])

*/
/*
stu.save(function(err) {
    if(!err) {
        console.log("保存成功~~~");
    }
});
*/
/*
    Document文档对象
    通过Model 对数据库进行查询时,会返回Document对象或Document对象数组。
    Document 继承自Model ,代表一个集合中的文档。
    Document 对象也可以和数据库进行交互操作。
*/
/*  Document文档对象:
    equals(doc) - 比较两个文档是否是同一个
    id   - 获取文档的_id属性值
    get(path,[type])     - 获取文档中的指定属性值
    set(path,value,[type])  - 设置文档的指定的属性值
    update(update,[options][callback])  - 修改对象
    save([callback])    - 保存
    remove([callback])   - 删除对象
    isNew   - 是否是一个新的文档 又没初始化或存进数据库
    isInit(path) - 存放路径 属性初始化
    toJSON()    - 转换为一个就JSON对象 *有问题*
    toObject() - 将Document对象转换为一个普通的JS对象
*/
StuModel.findOne({},function(err,doc){
    if(!err) {

        // console.log(doc);
       /* doc.update({$set:{age:38}},function(err) {
            if(!err) {
                console.log("修改成功~~");
            }
        });*/
        /*doc.age = 18;
        doc.save();*/

        /*doc.remove({},function(err) {
            if(!err) {
                console.log("大师兄再见了~~~");
            }
        });*/

        // console.log(doc.get("name")
        // console.log(doc.name,doc.age);
        // doc.set("name","朱晓晓");
        // doc.name = "赫赫";
        // console.log(doc._id);
        // let j = doc.toJSON();
        // console.log(j === doc);
        // let obj = doc.toObject();
        // obj.save();

        doc = doc.toObject();
        delete doc.address;
        console.log(doc._id);

    }else {
        console.log(err);
    }
});

Docuemnt和Model的方法对像

  • Document文档对象:
    • equals(doc) - 比较两个文档是否是同一个
    • id - 获取文档的_id属性值
    • get(path,[type]) - 获取文档中的指定属性值
    • set(path,value,[type]) - 设置文档的指定的属性值
    • update(update,[options][callback]) - 修改对象
    • save([callback]) - 保存
    • remove([callback]) - 删除对象
    • isNew - 是否是一个新的文档 又没初始化或存进数据库
    • isInit(path) - 存放路径 属性初始化
    • toJSON() - 转换为一个就JSON对象 有问题
    • toObject() - 将Document对象转换为一个普通的JS对象

  • Model 文档对象
    • 有了Model,就可以来对数据库进行增删改查的操作 Model.create(doc(s),[callback]);
    • 用来创建一个或多个文档并添加到数据库中
    • 参数:
      • doc(s) 可以是一个文档对象,也可以是一个文档对象的数组

      • callback 当操作完成以后调用的回调函数

    • 查询的:
      • Model.find (conditions, [projection], [options], [callback])

        • 查询所有符合条件的文档 总会返回一个数组
      • Model.findById(id, [projection], [options], [callback])

        • 根据文档的id属性查询文档 总会返回一个具体的文档对象
      • Model.findOne ([conditions],[projection], [options], [callback])

        • 查询符合条件的第一个文档 总会返回一个具体的文档对象
          • conditions 查询的条件
          • projection 投影 需要获取的字段
            • 两种方式: 1. {name:1, _id:0} 2. "name -_id"
          • options 查询的选项(skip limit )
          • callback 回调函数,查询的结果会通过回调函数返回 -回调函数必须传,如果不传回调函数,压根不会查询
      • 修改:

        • Model.update (conditions, doc, [options], [callback])

        • Model.updateMany (conditions, doc, [options], [callback])

        • Model.updateOne (conditions, doc, [options], [callback])

          • 用来修改一个或多个文档
          • 参数:
            • conditions 查询条件
            • doc 修改后的对象
            • options 配置参数
            • callback 回调函数
        • Model.replaceOne(conditions, doc,[options].[callback]) 替换

        • 删除:

          • Model.remove (conditions,[callback] )
          • Model.deleteOne(conditions,[callback] ) * ModeI.deleteMany(conditions,[callback] )
      • Model.count(conditions, [callback])

        • 统计文档的数量的

模块发

调用方

require("./too/conn_mongo");
let Student = require("./models/students");
let Teacher = require("./models/students");
// console.log(Student);

// Student.find({},function(err,docs) {
//         if(!err) {
//             console.log(docs);
//         }
// });

Teacher.create({
    username:"LHJ",
    age : 18,
    address:"中国"
});

模块1 连接数据库封装


/*
    定义一个模块,用来连接MongoDB数据库

*/
let mongoose = require("mongoose");
// mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open",function () {
    console.log("数据库已连接~~")
});


mongoose.connect("mongodb://127.0.0.1/mongoose_demo");

模块2 Model的封装


/*
    定义一个students的模型
*/
let mongoose = require("mongoose");
let Schema = mongoose.Schema;
let stusSchema = new Schema({
    name: String,
    age: Number,
    gender: {
        type: String,
        default : "female"
    },
    address: String,
});

let teaSchema = new Schema({
    username: String,
    age: Number,
    sex: {
        type: String,
        default: "man"
    },
    address: String,
});

// 定义模型
let StuModel = mongoose.model("student",stusSchema);
let TeaModel = mongoose.model("teacher",teaSchema);
module.exports = StuModel;
module.exports = TeaModel;