MongoDB_实战部分(二)

一、MongoDB CRUD操作

MongoDB 插入文档

/*
    向数据库插入文档
    db..insert()
    
    db..insertOne() 插入一个文档
    db..insertMany() 插入多个文档
    
    当我们向集合中插入文档时，如果每日一给文档指定_id属性，则数据库会自动给文档加_id,该属性用来作为文档的唯一标识
    手动生成唯一标识 ObjectId()
*/

/* 插入一个 */
db.system.version.insert({name:"猪八戒",age:28,gender:"男"})

/* 插入多个 */
db.system.version.insert([
    {name:"孙悟空",age:30,gender:"男"},
    {name:"沙和尚",age:30,gender:"男"},
    {name:"白骨精",age:25,gender:"女"},
])

db.system.version.find()

ObjectId()// 生成_id属性，根据时间戳生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

MongoDB 查询文档

/*
    查询
    db.collection.find()
    find()用来查询集合中所有符合条件的文档
    find()可以接受一个对象作为条件参数
        {}表示查询集合中所有的文档
        {属性：值}查询属性是指定值的文档
    find()返回的是一个数组
    
    db.collection.findOne()
    用来查询集合中符合条件的第一个文档
    findOne()返回的是一个文档对象
*/

db.system.version.find() // 查询全部
db.system.version.find({name:"猪八戒"})

db.system.version.findOne({name:"猪八戒"})

db.system.version.find({}).length() // 或者 db.system.version.find({}).count()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

MongoDB 修改文档

/*
    修改
    db.collection.update(查询条件，新对象)
    -update() 默认情况下会使用对象来替换旧的对象
    -如果需要修改指定的属性，而不是替换需要使用”修改操作符“来完成修改
        $set 可以用来修改文档中的指定属性
        $unset 可以用来删除文档的指定属性
    -默认只修改第一条数据，但你想修改多条数据，只需要添加multi属性
    
    db.collection.updateMany()
    -同时修改多个符合条件的文档
    
    db.collection.updateOne()
    -修改一个符合条件的文档
     
*/


// 用age:99 替换 name为沙和尚的那一条信息，相当于把那条信息全删了，只留age属性
db.system.version.update({name:"沙和尚"},{age:99})

// 用来设置属性或添加属性，不回替换
db.system.version.update(
    {"name":"猪八戒"},
    {$set:{address:"高老庄"}},
    {multi:true} // 修改多个,默认修改一个
)

// 删除_id为6386be638f7881827d491597 的数据
db.system.version.update(
    {"_id":ObjectId("6386be638f7881827d491597")},
    {$unset:{}}
)

// updateOne 修改一个
db.system.version.updateOne(
    {"name":"猪八戒"},
    {$set:{address:"嘿嘿"}}
)
// 修改多个
db.system.version.updateMany(
    {"name":"猪八戒"},
    {$set:{address:"呵呵呵"}}
)


db.system.version.find()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

MongoDB 删除文档

/*
    db.collections.remove()
    -删除符合条件的所有的文档（默认情况下会删除多个）
    -如果remove()第二个参数传递一个true，则只会删除一个
    -remove()必须传参
    
    db.collections.deleteOne()
    db.collections.deleteMany()
    
    db.collections.drop() 删除集合
    db.dropDatabase() 删除数据库

*/

db.system.version.find()

db.system.version.remove({name:"猪八戒"},true)

db.system.version.insert([{name:"猪八戒",age:30,gender:"男"},{name:"猪八戒",age:99,gender:"男"}])

// 清空集合（性能略差）
db.system.version.remove({})

// 显示集合中的文档
show collections

// 删除集合
db.system.version.drop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

练习题

//1.进入my_test数据库
use my_test


//2.向数据库的user集合中插入一个文档
db.user.insert({username:"小明"})

show collections

//3.查询user集合中的文档
db.user.find()

//4.向数据库的user集合中插入一个文档
db.user.insert({username:"小红"})
db.user.insert({username:"sunwukong"})
//5.查询数据库user集合中的文档
db.user.find()

//6.统计数据库user集合中的文档数量
db.user.find().count()

//7.查询数据库user集合中username为sunwukong的文档
db.user.find({username:"sunwukong"})

//8.向数据库user集合中的username为sunwukong的文档，添加一个address属性，属性值为huaguoshan
db.user.update({"username":"sunwukong"},{$set:{address:"huanguoshan"}})

//9.使用{username : "tangseng"}替换username为 zhubajie的文档
db.user.insert({username:"zhubajie"})

db.user.replaceOne({username:"zhubajie"},{username : "tangseng"})

//10.删除username为sunwukong的文档的address属性
db.user.update({"username":"sunwukong"},{$unset:{address:1}})

//11.向username为sunwukong的文档中，添加一个hoby:{cities:["beijing", shanghai", "shenzhen"]，movies:["sanguo" , "hero")}
// MongoDB的文档属性值也可以是一个文档，当一个文档的属性值是一个文档时，我们称这个文档叫做，内嵌文档
db.user.update({"username":"sunwukong"},{$set:{hobby:{cities:["beijing", "shanghai", "shenzhen"],movies:["sanguo" , "hero"]}}})

//12.向username为tangseng的文档中，添加一个hobby:{movies: [ "A Chinese Odyssey" , "King of comedy"]}
db.user.update({"username":"tangseng"},{$set:{hobby:{movies: [ "A Chinese Odyssey" , "King of comedy"]}}})

//13.查询喜欢电影hero的文档
// MongoDB支持直接通过内嵌文档的属性进行查询，如果要查询内嵌文档则可以通过.的形式来匹配
// 如果要通过内嵌文档来对文档进行查询，此时属性名必须使用引号
db.user.find({"hobby.movies":"hero"})

//14.向tangseng中添加一个新的电影Interstellar
// $push 用于向数组中添加一个新的元素
// $addToSet 向数组中添加一个新元素，如果数组中已经存在了该元素，则不会添加
db.user.update({"username":"tangseng"},{$push:{"hobby.movies":"Interstellar"}})

db.user.find()

//15.删除喜欢beijing的用户
db.user.remove({"hobby.cities":"beijing"})

//16.删除user集合
db.user.drop()

show dbs
//17.向numbers中插入20000条数据
db.numbers.remove({})
var arr = []
for(var i=1; i<=20000; i++){
    arr.push({num:i})
}
db.numbers.insert(arr)

db.numbers.find()

//18.查询numbersp num为 500的文档
db.numbers.find({num:500})

//19.查询numbers中 num大于 500的文档
db.numbers.find({num:{$gt:500}}) // $gt > ; $gte >=

//20.查询numbers中num小于 30的文档
db.numbers.find({num:{$lt:30}}) // $lt < ; $lte <=

//21.查询numbers中 num大于 40小于50的文档
db.numbers.find({num:{$gt:40,$lt:50}})

//22.查询numbersp num大于 19996的文档
db.numbers.find({num:{$gt:19996}})

//23.查看numbers集合中的前10条数据
db.numbers.find().limit(10) // limit限制条数

//24.查看numbers集合中的第11条到20条数据
// skip（）用于跳过指定数量的数据
// skip(10).limit(10) 跳过前10条数据，从第11条开始显示，限制10条数据
db.numbers.find().skip(10).limit(10)

//25.查看numbers集合中的第21条到30条数据
db.numbers.find().skip(20).limit(10)

// MongoDB会自动调整skip和limit的位置
db.numbers.find().limit(10).skip(10)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

二、Mongoose

Mongoose是一个对象文档模型（ODM）库，它对Node原生的MongoDB模块进行了进一步的优化封装，并提供了更多的功能。

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

• Schema（模式对象）
  Schema对象定义约束了数据库中的文档结构；
• Model
  Model对象作为集合中的所有文档的表示，相当于MongoDB数据库中的集合collection；
• Document
  Document表示集合中的具体文档，相当于集合中的一个具体的文档。

三、VSCode连接MongoDB

/*
  1、下载安装Mongoose
   npm i mongoose --save
  2、在项目中引入mongoose
   var mongoose = require("mongoose");
  3、连接MongoDB数据库
   mongoose.connect('mongodb://数据库的ip地址：端口/数据库'，{useMongoClient:true});
   - 如果端口号是默认端口号（27017）则可以省略不写
    mongoose.connect('mongodb://127.0.0.1/my_test');

  
   -监听MongoDB数据库的连接状态
   mongoose.connection.once("open",function(){
      console.log("数据库连接成功~~~");
    });

    mongoose.connection.once("close",function(){
      console.log("数据库连接已经断开~~~");
    });

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

// 引入
var mongoose = require("mongoose");

// 连接数据库
mongoose.connect('mongodb://127.0.0.1/my_test');

mongoose.connection.once("open",function(){
  console.log("数据库连接成功~~~");
});

// 将mongoose.Schema赋值给一个变量
var Schema = mongoose.Schema;

// 创建Schema（模式）对象
var stuSchema = new Schema({
  name:String,
  age:Number,
  gender:{
    type:String,
    default:"female"
  },
  address:String
});

// 通过schema来创建Model
// Model代表的是数据库中的集合，通过Model才能对数据库进行操作
// mongoose.model(modelName,schem);
//modelName 就是要映射的集合名 mongoose会自动将集合名变成复数
var StuModel = mongoose.model("students",stuSchema)

// 向数据库中插入一个文档
StuModel.create({
  name:"白骨精",
  age:20,
  address:"山洞"
},function(err) {
  if(!err) {
    console.log("插入成功！");
  }
})

/* 
  查询
  Model.find(conditions,[projection],[options],[callback]) 查询所有符合条件的文档

  Model.findById(id,[projection],[options],[callback]) 根据文档的id属性查询文档

  Model.findOne([conditions],[projection],[options],[callback]) 查询符合条件的第一个文档 总和返回一个具体的文档

  conditions 查询的条件
  projection 投影，设置你想要的字段
    {name:1,_id:0} 或 {name,age,-_id}
  options 查询选项
    {skip:2,limit:1} 跳过三个，显示1个数据
  callback 回调函数，查询结构会通过回调函数返回，如果不传回调函数，压根不会查询
*/

StuModel.find({},"name age -_id",{skip:2,limit:1},function(err,docs) {
  if(!err) {
    // docs 是数组 是Document，文档对象
    // Document对象是Model的实例
    console.log(docs);
  }
})

/* 
  修改
  Model.update(conditions,doc,[options],[callback])
  Model.updateMany(conditions,doc,[options],[callback])
  Model.updateOne(conditions,doc,[options],[callback])
    - 用来修改一个或多个文档
    - 参数：
    conditions 查询条件
    doc 修改后的对象
    options 配置参数
    callback 回调函数
*/

// 修改唐僧的年龄为20
/* StuModel.updateOne({name:"孙悟空"},{$set:{age:20}},function(err) {
  if(!err) {
    console.log("修改成功");
  }
}) */

/* 
  删除
  Model.remove(conditions,[callback])
  Model.deleteOne(conditions,[callback])
  Model.deleteMany(conditions,[callback])
*/

/* StuModel.remove({name:"猪八戒"},function(err) {
  if(!err) {
    console.log("删除成功！");
  }
}) */

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

StuModel.count({},function(err,count) {
  if(!err) {
    console.log(count);
  }
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

模块化

./model/student.js

var mongoose = require("mongoose");

// 将mongoose.Schema赋值给一个变量
var Schema = mongoose.Schema;

// 创建Schema（模式）对象
var stuSchema = new Schema({
  name:String,
  age:Number,
  gender:{
    type:String,
    default:"female"
  },
  address:String
});

var StuModel = mongoose.model("students",stuSchema);

exports.model = StuModel;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

./tools/conn_mongoose.js

// 引入
var mongoose = require("mongoose");

// 连接数据库
mongoose.connect('mongodb://127.0.0.1/my_test');

mongoose.connection.once("open",function(){
  console.log("数据库连接成功~~~");
});
1
2
3
4
5
6
7
8
9
10
11

./测试模块化.js

require("./tools/conn_mongoose.js")

var Student = require("./model/student.js").model;

Student.find({},function(err,docs) {
  if(!err) {
    console.log(docs);
  }
});
1
2
3
4
5
6
7
8
9
10
11

结果截图：

MongoDB中文手册
MongoDB官方文档