mongoose

结构

1. 创建一个数据库 集合
2. Schema： 数据库集合的模型骨架，或者说是表结构
3. Model： 通过Schema构造的，还可以操作数据库
4. Entity： 通过Model创建的，也可以操作数据库，不过操作的是当前的实体

基本使用

连接数据库

1. 安装mongoose

npm install mongoose

2. 使用

const mongoose = require('mongoose')
// 连接数据库
const db = mongoose.connect('mongodb://user:pass@localhost:port/database')
// 监听
db.connection.on('error', error => {
    console.log('数据库连接失败： ', error)
})

db.connection.on('open', () => {
    console.log('数据库连接成功！')
})

生成一个基本数据

const mongoose = require('mongoose')
// 连接数据库
const db = mongoose.connect('mongodb://user:pass@localhost:port/database')
// 监听
db.connection.on('error', error => {
    console.log('数据库连接失败： ', error)
})

db.connection.on('open', () => {
    console.log('数据库连接成功！')
})
// 定义模型数据结构
const TestSchema = new mongoose.Schema({
    name: { type: String, default: '' },
    age: { type: Number, default: 0 },
    time: { type: Date, default: Date.now() },
    email: { type: String }
})

// 使用Schema创建Model
const TestModel = db.model('test1', TestSchema)

// 使用model创建一个实体
const TestEntity = new TestModel({
    naem: 'zhangSan',
    age: 36,
    email: '123@qq.com'
})
console.log(TestEntity.name) // zhangSan
console.log(TestEntity.tiem) // 创建时默认生成的时间

// 实体存入数据库生成文档
TestEntity.save((error, doc) => {
    if (error) {
       console.log('当前文档存入集合失败', error)
       return false
    }
    // 插入的这条文档
    console.log(doc)
})

简单查询

1. 第一个参数是查询条件，如果没有则默认查询全部
2. 第二个参数是查询后返回的结果数组

这里只是简单的，其实应该是四个参数，在后面提到

TestModel.find({}, (error, docs) => {
    // 查询出全部数据
    console.log(docs)
})

TestModel.find({
    age: 36
}, (error, docs) => {
    // 查询出 age 是 36 的数据
    console.log(docs)
})

基本新增数据

1. model保存

第一个参数是插入的数据，可以是一条对象，也可以是多条对象构成的数组

TestModel.create({
    name: 'liSi',
    age: 20,
    email: 'lisi@qq.com'
}, (error, doc) => {
    // 当前插入的这条
    console.log(doc)
})

2. Entity保存

const TestEntity = new TestModel({
    name: 'liSi',
    age: 18,
    email: 'lisi@qq.com'
});
TestEntity.save((error, doc) => {
    // 当前插入的这条
    console.log(doc)
})

基本更新数据

1. 第一个参数：查询条件
2. 第二个参数：更新对象
3. 第三个参数：callback

TestModel.update({ age: 18 }, { $set: { age: 16 } }, (error) => {
    if (error) {
        conosle.log('更新失败 >>> ', error)
        return false
    }
    console.log('更新成功')
})

基本删除数据

TestModel.remove({ email: 'lisi@qq.com' }, error => {
    if (error) {
        console.log(error)
        return false
    }
    console.log('删除成功')
})

查询

find

1. 第一个参数： 查询条件
2. 第二个参数： 过滤条件
3. 第三个参数： option（游标）， 对要返回的数据处理
4. 第四个参数： callback

正常只需要把显示的属性设置为大于零就行，默认是零（不显示）,除了_id的默认是显示。如果对不需要显示的属性设置零会报错或者无结果，除非是_id

TestModel.find({}, { name: 1, age: 1, _id:0 }, (error, docs) => {
    // 查询全部，返回显示一个键值name、age的值，其他不显示
    console.log(docs)
})

findOne

使用和 find 一样，只是返回单个结果（也就是第一个查询到的，并停止查询）

findById

使用和 findOne 一样，返回单个结果,但是只接受文档的_id作为参数

TestModel.findById('obj._id', function (err, doc){
 // 查询的单个文档
 console.log(doc)
}); 

条件查询

条件	含义
$lt	小于
$lte	小于等于
$gt	大于
$gte	大于等于
$ne	不等于
$in	可单值和多个值匹配
$or	查询多个键值的任意给定值
$exists	表示是否存在
$all	所有

TestModel.find({ age: { $gt: 18 }}, (error, docs) => {
    // > 18
    console.log(docs)
})

TestModel.find({ age: { $gte: 18, $lt: 60 }}, (error, docs) => {
    // 18 <= x < 60
    console.log(docs)
})

TestModel.find({ name: 'test', age: {$in: [20, 30]}}, (error, docs) => {
    // name: test 且 age 包含 20或者30
    console.log(docs)
})

TestModel.find({
    $or: [
        { name: 'test'},
        { age: { $gte: 18 } }
    ]
}, (error, docs) => {
    // name: test 或者 age >= 18
    console.log(docs)
})

TestModel.find({ name: { $exists: true }}, (error, docs) => {
    // name存在的
    console.log(docs)
})

TestModel.find({ name: { $exists: false }}, (error, docs) => {
    // name不存在的
    console.log(docs)
})

游标

对查询返回的结果进行控制

limit

TestModel.find({}, null, { limit: 10 }, (err, docs) => {
    // 最多返回10个
})

skip

TestModel.find({}, null, { skip: 10 }, (err, docs) => {
    // 返回从11-20的
})

sort

1是升序，-1是降序

TestModel.find({}, null, { sort: { age: -1 } }, (err, docs) => {
    // 按 age 倒序返回
})

mongoose属性或者方法

ObjectId

一个12字节的BSON类型字符串

• 4字节： UNIX时间戳
• 3字节： 表示运行MongoDB的机器
• 2字节： 表示生成此_id的进程
• 3字节： 由一个随机数开始的计数器生成的值

为Schema添加属性值

当最初定义的Schema不满足时

const mongoose = requrie('mongoose')
const Schema = new mongoose.Schema
Schema.add({
    name: String,
    email: String,
    age: Number
})

在Schema创建实例方法

有的时候，我们创造的Schema不仅要为后面的Model和Entity提供公共的属性，还要提供公共的方法.

const mongoose = require('mongoose')
const saySchema = new mongoose.Schema({name: String})
saySchema.method('say', () => {
    console.log('say method')
})
const sayModel = mongoose.model('say', saySchema)
const say = new sayModel()
say.say() // say method

为Schema创建静态方法

const mongoose = require('mongoose')
const db = mongoose.connect("mongodb://127.0.0.1:27017/test")
const TestSchema = new mongoose.Schema({
    name : { type:String },
    age  : { type:Number, default:0 },
    email: { type:String, default:"" },
    time : { type:Date, default:Date.now() }
})
TestSchema.static('findByName', function (name, callback) {
    return this.find({name}, callback)
})
const TestModel = db.model('test1', TestSchema)
TestModel.findByName('test', (err, docs) => {
    // name 为 test的 
    console.log(docs)
})

为Schema追加方法

const mongoose = require("mongoose")
const db = mongoose.connect("mongodb://127.0.0.1:27017/test")
const TestSchema = new mongoose.Schema({
    name : { type:String },
    age  : { type:Number, default:0 },
    email: { type:String, default:"" },
    time : { type:Date, default:Date.now }
})
 
TestSchema.methods.speak = function(){
  console.log('我的名字叫'+this.name)
}
 
const TestModel = db.model('test1',TestSchema)
const TestEntity = new TestModel({name:'Lenka'})
TestEntity.speak() // 我的名字叫Lenka

连接

connect

const mongoose = require('mongoose')
mongoose.connect(mongodb://localhost/test)
const db = mongoose.connection
db.once('open', () => {
    // code
})
const schema = mongoose.Schema({
    name: String
})
const model = mongoose.model('test', schema)
const zhangSan = new model({ name: 'zhangSan' })
zhangSan.save(err => {
    // code
})

createConnection

const mongoose = require('mongoose')

const db = mongoose.createConnection('localhost', 'test')

const schema = new mongoose.Schema({
    name: String
})
const collectionName = 'user'
const model = db.model('test', schema, collectionName)
const zhangSan = new model({ name: 'zhangSan' })
zhangSan.save(err => {
    // code
})

区别

1. 如果只使用一个数据库，推荐使用 mongoose.connect()；如果需要创建额外的连接，需要使用 mongoose.createConection()
2. 连接后，使用mongoose.connect()的连接就是mongoose.connection；使用mongoose.createConnection()的连接就是它的返回值

查询出的结果去重（distinct）

TestModel.distinct(field, conditions, callback)
TestModel.distinct(field, conditions)
TestModel.distinct(field, callback)
TestModel.distinct(field)

• field：去重的依据的字段及返回的字段
• conditions：查询的条件
• callback：查询结果的回调，如果后面跟exec()的话，则是then

后面不能跟sort，skip之类的方法。折中的方案，可以将结果使用find方法再做一次查询