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

章越

2023-12-01

数据库介绍分类

数据库(Database)

我们的程序都是在内存中运行的,一旦程序运行结束或者计算机断电,程序运行中的数据都会丢失。
数据库是按照数据结构来组织、存储和管理数据的仓库。数据库就是存储数据的仓库。
数据库分类 - SQL 结构化查询语言
- 数据库主要分成两种:
  - 关系型数据库（RDBMS）
    ● MySQL、 Oracle、 DB2、SQL Server …
    ● 关系数据库中全都是表
  - 非关系型数据库（No SQL Not Olny SQL）
    ● MongoDB、 Redis …
    ● 键值对数据库
    ●文档数据库 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来操作

安装MongoDB
配置环境变量
- C: \Program Fi les \MongoDB\Server\3.2\bin
创建数据库的存放的路径：在c盘根目录或自定义
- 创建一个文件夹data
- 在data中创建一个文件夹db
- 自定义路径：mongod --dbpath C:\Users\Desktop\data\db --port 10086 -->： C:\Users\Desktop\data\db (数据库路径) --port 端口号（建议：10086 以上，65535 以下-默认是27017）
打开cmd命令行窗口,不要关闭
- 输入mongod启动 mongodb服务器
- 32位注意:第一次启动服务器时，需要输入如下内容：mongod --storageEngine=mmapv1 以后就可以 mongod 启动
再打开一个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表示集合中的具体文档,相当于集合中的一个具体的文档

使用

下载安装Mongoose
npm i mongoose --save
在项目中引入 mongoose
let mongoose = require(“mongoose”);
连接MongoDB数据库
mongoose.connect(‘mongodb://数据库的ip地址:端口号/数据库名’);
- 如过端口号是默认端口号（27017）则可以省略不写
断开数据库连接（一般不需要使用）
- 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;

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

数据库介绍分类

MongoDB简介下载

安装MongoDB

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

图形化界面安装

基本指令

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

数据运算操作符

比较

逻辑

元素

评估

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

基本指令复习

文档之间的关系

Mongoose安装和简介

使用

关键字

Mongoose案例

Model增删查改案例

Document案例

Docuemnt和Model的方法对像

模块发

相关阅读

相关文章

相关问答

相关文档

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

数据库介绍分类

MongoDB简介 下载

安装MongoDB

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

图形化界面安装

基本指令

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

数据运算操作符

比较

逻辑

元素

评估

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

基本指令复习

文档之间的关系

Mongoose安装和简介

使用

关键字

Mongoose案例

Model增删查改案例

Document案例

Docuemnt和Model的方法对像

模块发

相关阅读

相关文章

相关问答

相关文档

MongoDB简介下载