互联网行业的发展非常的迅速，数据存储以及架构优化方面也有很多不同的解决方案，例如关系型数据库、非关系型数据库、数据仓库技术等。更多数据库类产品的出现，为我们很好的解决了数据存储的问题，例如Redis缓存，MySQL关系型数据库，MongoDB文档型数据库，Hbase数据仓库等。
随着业务的发展，在对架构优化时，选取了MongoDB存储一部分数据，作为一个运维人员只能迎头赶上，去学习操作和维护相关知识。下面的文档就是自己学习MongoDB数据库的学习笔记，主要有以下特点：
1、理论较少，主要是实际操作，
2、和关系型数据库MySQL对比学习，主要是一些操作方面。俗话说没有对比，就没有伤害，两个不同类型的数据库对比学习，会更好的提高学习效率。
一、库的操作
MySQL与MongoDB在 库、表、数据等概念上有以下差异，MySQL中有数据库Database,表 table，数据行列等概念，而MongoDB中没有表和行列等概念，主要包含数据库Database,集合collections，以及文档。
RDBMS vs NoSQL
RDBMS
- 高度组织化结构化数据
- 结构化查询语言（SQL） (SQL)
- 数据和关系都存储在单独的表中。
- 数据操纵语言，数据定义语言
- 严格的一致性
- 基础事务
NoSQL
- 代表着不仅仅是SQL
- 没有声明性查询语言
- 没有预定义的模式
-键 - 值对存储，列存储，文档存储，图形数据库
- 最终一致性，而非ACID属性
- 非结构化和不可预知的数据
- CAP定理
- 高性能，高可用性和可伸缩性
1.1 查看所有数据库（已经存在）
|
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
|
#MySQL
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| winner |
+--------------------+
4 rows
in
set
(0.04 sec)
#MongoDB
[root@iZ23t094y03Z ~]
# mongo
MongoDB shell version: 2.4.14
connecting to:
test
> show dbsshow dbs
col 0.203125GB
local
0.078125GB
test
0.203125GB
winner2 0.203125GB
查看当前数据库
mysql>
select
database();
+------------+
| database() |
+------------+
| NULL |
+------------+
1 row
in
set
(0.03 sec)
mysql> use winner
Database changed
mysql>
select
database();
+------------+
| database() |
+------------+
| winner |
+------------+
1 row
in
set
(0.00 sec)
#MongoDB
> db db
test
|
注意事项：
在MongoDB里面，连接数据库服务端时，在不指定数据库名时。默认test库，而MySQL默认是空，当我们切换到具体数据库时，才能看到具体的当前数据库信息。
1.2切换数据库
在切换数据库时，命令都是使用use + 库名，但是两者之间还是有比较大的区别，MongoDB中，如果没有输入的库名，它会创建一个库名，而MySQL在所有当前库中，没有你输入的数据库名时，会报错。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
> show dbs
col 0.203125GB
local
0.078125GB
test
0.203125GB
winner2 0.203125GB
> use win
switched to db win
> db
win
#MySQL
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| winner |
+--------------------+
4 rows
in
set
(0.00 sec)
mysql> use win;
ERROR 1049 (42000): Unknown database
'win'
mysql>
|
1.3创建数据库
MongoDB没有具体的创建数据库的命令，一般在切换的过程中，如果不存在该数据库，就会新建数据库，而MySQL中有create database databasename语句创建数据库。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
mysql> use win;
ERROR 1049 (42000): Unknown database
'win'
#未创建前
mysql> create database win;
#创建语句 一般我们创建时 还会指定字符集什么的
Query OK, 1 row affected (0.00 sec)
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| win |
| winner |
+--------------------+
5 rows
in
set
(0.00 sec)
MongoDB
use DATABASE_NAME
如果数据库不存在，则创建数据库，否则切换到指定数据库。
|
1.4 删除数据库
刚学完创建和切换，创建后，我们又不想要它了，所以我们考虑一下如何删除呢？？？MongoDB中用db.dropDatabase()删除当前库，而MySQL中使用 drop database databasename;删除你要删除的库。
|
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
|
MySQL
mysql> create database winner2;
#创建库
Query OK, 1 row affected (0.00 sec)
mysql> use winner2;
#切换库
Database changed
mysql>
select
database();
#查看当前库
+------------+
| database() |
+------------+
| winner2 |
+------------+
1 row
in
set
(0.00 sec)
mysql> drop database winner2;
#删除winner2
Query OK, 0 rows affected (0.00 sec)
mysql>
select
database();
#查看当前库
+------------+
| database() |
+------------+
| NULL |
+------------+
1 row
in
set
(0.00 sec)
MongoDB
use winner2
#创建winner库
switched to db winner2
show dbs;
#查看当前所有的库
col 0.203125GB
winner2 0.203125GB
db
#查看当前库
winner2
MySQL中删除某个当前库后，再次查看当前库是NULL，而MongoDB中删除当前库后，仍然显示当前库
db.dropDatabase()
#删除当前库
{
"dropped"
:
"winner2"
,
"ok"
: 1 }
> db 检查当前库
winner2
show dbs
#检查所有的库
col 0.203125GB
>
|
2、表与集合操作
在我们学习过数据库相关理论知识后，我们都知道数据是存储在表中，而数据库是用来存储数据表的。而MongoDB和MySQL的表概念是不一样的，MongoDB是将文档数据存储在集合（collection）中，而MySQL是将数据存储在表（table）中，集合是没有表的结构的，而表是有相关的结构，例如字段、字段类型、索引、主键、存储引擎等。
2.1 查看当前所有表
|
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
|
#MySQL
mysql> use mysql
Reading table information
for
completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> show tables;
+---------------------------+
| Tables_in_mysql |
+---------------------------+
| columns_priv |
| db |
| event |
| func |
| general_log |
| help_category |
| help_keyword |
| help_relation |
| help_topic |
| innodb_index_stats |
| innodb_table_stats |
#MongoDB
show dbs
col 0.203125GB
> use col
switched to db col
> show collections
system.indexes
winner
winner2
>
|
2.2 创建表或者集合
MySQL数据是存储在相关的表中，而MongoDB数据是存储在集合中，MySQL由于支持插件式存储引擎，字段类型、索引、主键、等原因，让其创建表结构的语句比较复杂，在应用系统中，性能优化等情况和表结构息息相关。而MongoDB主要是用来存储key(values)类型的数据，所以要简单很多。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
mysql> use winner
Database changed
mysql> show tables
-> ;
Empty
set
(0.00 sec)
mysql> create table winer(
id
int not null primary key auto_increment,
-> name varchar(20) not null ,
-> age tinyint not null,
-> sex tinyint not null default
'0'
) engine=innodb charset utf8;
Query OK, 0 rows affected (0.24 sec)
mysql> desc winer;
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
|
id
| int(11) | NO | PRI | NULL | auto_increment |
| name | varchar(20) | NO | | NULL | |
| age | tinyint(4) | NO | | NULL | |
| sex | tinyint(4) | NO | | 0 | |
+-------+-------------+------+-----+
#MongoDB创建集合
在MongoDB中，要操作一个集合，并不需要先创建它。可以直接往集合里面插入数据，如果集合不存在，
会自动创建集合，并插入数据。
|
2.3 表与集合的增删改查
在知道了如何创建一个表、集合等相关知识后，我们就要想着如何对表或者集合数据做修改，而我们的应用系统、业务系统中存储的数据主要就是增删改查等相关的操作。
2.3.1插入数据
MySQL中插入数据
创建表SQL语句
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
CREATE TABLE `winer` (
`
id
` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) NOT NULL,
`age` tinyint(4) NOT NULL,
`sex` tinyint(4) NOT NULL DEFAULT
'0'
,
PRIMARY KEY (`
id
`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
表结构
mysql> desc winer
-> ;
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
|
id
| int(11) | NO | PRI | NULL | auto_increment |
| name | varchar(20) | NO | | NULL | |
| age | tinyint(4) | NO | | NULL | |
| sex | tinyint(4) | NO | | 0 | |
+-------+-------------+------+-----+---------+----------------+
4 rows
in
set
(0.00 sec)
|
1、插入单条数据
|
1
2
3
4
5
6
7
8
9
10
11
|
mysql> insert into winer (name,age,sex) values(
"MySQL"
,20,1)
-> ;
Query OK, 1 row affected (0.09 sec)
mysql>
select
* from winer;
+----+-------+-----+-----+
|
id
| name | age | sex |
+----+-------+-----+-----+
| 1 | MySQL | 20 | 1 |
+----+-------+-----+-----+
1 row
in
set
(0.00 sec)
|
2、批量插入
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
mysql> insert into winer (name,age,sex) value(
"MySQL"
,20,1),(
"Docker"
,8,0)
-> ;
Query OK, 2 rows affected (0.00 sec)
Records: 2 Duplicates: 0 Warnings: 0
mysql> insert into winer (name,age,sex) values(
"MySQL"
,20,1),(
"Docker"
,8,0)
-> ;
Query OK, 2 rows affected (0.01 sec)
Records: 2 Duplicates: 0 Warnings: 0
两个插入语句之间区别value和values两者都能插入单个值或者批量值
mysql>
select
* from winer;
+----+--------+-----+-----+
|
id
| name | age | sex |
+----+--------+-----+-----+
| 1 | MySQL | 20 | 1 |
| 2 | MySQL | 20 | 1 |
| 3 | Docker | 8 | 0 |
| 4 | MySQL | 20 | 1 |
| 5 | Docker | 8 | 0 |
+----+--------+-----+-----+
5 rows
in
set
(0.00 sec)
|
3、其他插入数据的方法
MySQL中除了传统的insert into插入数据外，我们还可以用load data mysqlimport等方式导入数据，也可以将其他表中的数据插入到某张表中，具体方法不做详细描述。
2.3.2 MongoDB中插入数据
MongoDB主要存储的是文档数据，文档的数据结构和JSON基本一样。所有存储在集合中的数据都是BSON格式。BSON是一种类json的一种二进制形式的存储格式,简称Binary JSON。
插入文档
MongoDB 使用 insert() 或 save() 方法向集合中插入文档，语法如下：
|
1
2
3
|
db.COLLECTION_NAME.insert(document)
db.COLLECTION_NAME.save(document)
|
1、简单的插入
|
1
2
3
4
5
6
|
db.winner.
find
()
#插入前 MongoDB中用find查看以前的数据类似mysql中的select
> db.winner.insert({name:
"linux"
})
#插入结果
>db.winner.
find
()
{
"_id"
: ObjectId(
"592bf6bf1b8e279c43cbb021"
),
"name"
:
"linux"
}
>
|
2、定义变量
|
1
2
3
4
5
6
7
8
9
10
|
> SQLNAME=({
"titile"
:
"MongoDB学习实践"
,
description:
"MongoDB是NoSQL数据库"
,
by:
"书籍学习"
})
可以将我们要插入的数据定义成变量，后面使用加载变量的方式来实现数据的插入
> db.sql.insert(SQLNAME)
> db.sql.
find
()
{
"_id"
: ObjectId(
"592bf8b5f3fed7ab45761fc1"
),
"titile"
:
"MongoDB学习实践"
,
"description"
:
"MongoDB是NoSQL数据库"
,
"by"
:
"书籍学习"
}
>
|
3、for循环插入
|
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还支持
for
(i=0;i<100;i++)db.winner2.insert({x:i})这种形式的数据插入。
for
(i=0;i<100;i++)db.winner2.insert({x:i})
for
(i=0;i<100;i++)db.winner2.insert({x:i})
> db.winner2.
find
()db.winner2.
find
()
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da3"
),
"x"
: 0 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da4"
),
"x"
: 1 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da5"
),
"x"
: 2 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da6"
),
"x"
: 3 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da7"
),
"x"
: 4 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da8"
),
"x"
: 5 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372da9"
),
"x"
: 6 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372daa"
),
"x"
: 7 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372dab"
),
"x"
: 8 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372dac"
),
"x"
: 9 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372dad"
),
"x"
: 10 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372dae"
),
"x"
: 11 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372daf"
),
"x"
: 12 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372db0"
),
"x"
: 13 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372db1"
),
"x"
: 14 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372db2"
),
"x"
: 15 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372db3"
),
"x"
: 16 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372db4"
),
"x"
: 17 }
{
"_id"
: ObjectId(
"592bfaa425e6a2cd19372db5"
),
"x"
: 18 }
#db.winner2.count() #统计数据条数 类似MySQL中的 select count(*) from tablename where *
100
|
2.3.3删除数据
1、MySQL中删除数据
MySQL中删除数据最常用的是delete结合where子句的方式，在清空表的时候可用truncate,delete不加限制条件时时删除整个表的数据，但是当表中存在自增主键列时，新增加的数据主键自增列不会从初始化数字开始，而是从之前被删除的位置继续，而truncate是清空表，对整个表中的自增主键列重新初始化。
|
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
|
mysql>
select
count(*) from winer;
+----------+
| count(*) |
+----------+
| 160 |
+----------+
1 row
in
set
(0.03 sec)
mysql>
select
* from winer limit 10;
+----+--------+-----+-----+
|
id
| name | age | sex |
+----+--------+-----+-----+
| 1 | MySQL | 20 | 1 |
| 2 | MySQL | 20 | 1 |
| 3 | Docker | 8 | 0 |
| 4 | MySQL | 20 | 1 |
| 5 | Docker | 8 | 0 |
| 6 | MySQL | 20 | 1 |
| 7 | MySQL | 20 | 1 |
| 8 | Docker | 8 | 0 |
| 9 | MySQL | 20 | 1 |
| 10 | Docker | 8 | 0 |
+----+--------+-----+-----+
10 rows
in
set
(0.00 sec)
用delete删除全部数据
mysql> delete from winer;
Query OK, 160 rows affected (0.01 sec)
再插入数据
mysql> insert into winer (name,age,sex)
select
name,age,sex from winner2;
Query OK, 5 rows affected (0.01 sec)
Records: 5 Duplicates: 0 Warnings: 0
#检查数据的主键情况，确实是从之前的删除前开始存储的，而并不是重新开始。
mysql>
select
* from winer;
+-----+--------+-----+-----+
|
id
| name | age | sex |
+-----+--------+-----+-----+
| 249 | MySQL | 20 | 1 |
| 250 | MySQL | 20 | 1 |
| 251 | Docker | 8 | 0 |
| 252 | MySQL | 20 | 1 |
| 253 | Docker | 8 | 0 |
+-----+--------+-----+-----+
5 rows
in
set
(0.00 sec)
truncate 删除检查
mysql> truncate winer;
Query OK, 0 rows affected (0.09 sec)
mysql> insert into winer (name,age,sex)
select
name,age,sex from winner2;
Query OK, 5 rows affected (0.01 sec)
Records: 5 Duplicates: 0 Warnings: 0
mysql>
select
* from winer;
+----+--------+-----+-----+
|
id
| name | age | sex |
+----+--------+-----+-----+
| 1 | MySQL | 20 | 1 |
| 2 | MySQL | 20 | 1 |
| 3 | Docker | 8 | 0 |
| 4 | MySQL | 20 | 1 |
| 5 | Docker | 8 | 0 |
+----+--------+-----+-----+
5 rows
in
set
(0.00 sec)
主键从1开始。
truncate 释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放
|
2、MongoDB中删除数据
MongoDB remove()函数是用来移除集合中的数据。在执行remove()函数前先执行find()命令来判断执行的条件是否正确，这是一个比较好的习惯。数据的删除应该是一个很严谨的操作，不能随意的操作，无论是MySQL还是MongoDB，或者其他的数据库，我们都应该养成这样的良好习惯。严格条件限制、备份、谨慎等。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
remove() 方法的基本语法格式如下所示：
db.collection.remove(
<query>,
<justOne>
)
MongoDB 是 2.6 版本以后的，语法格式如下：
db.collection.remove(
<query>,
{
justOne: <boolean>,
writeConcern: <document>
}
)
参数说明：
query :（可选）删除的文档的条件。
justOne : （可选）如果设为
true
或 1，则只删除一个文档。
writeConcern :（可选）抛出异常的级别
|
|
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
|
根据筛选条件 删除部分数据
> db.winner.
find
()db.winner.
find
()
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f09"
),
"x"
: 0 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f0b"
),
"x"
: 2 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f0c"
),
"x"
: 3 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f0d"
),
"x"
: 4 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f0e"
),
"x"
: 5 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f0f"
),
"x"
: 6 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f10"
),
"x"
: 7 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f11"
),
"x"
: 8 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f12"
),
"x"
: 9 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f13"
),
"x"
: 10 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f14"
),
"x"
: 11 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f15"
),
"x"
: 12 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f16"
),
"x"
: 13 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f17"
),
"x"
: 14 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f18"
),
"x"
: 15 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f19"
),
"x"
: 16 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f1a"
),
"x"
: 17 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f1b"
),
"x"
: 18 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f1c"
),
"x"
: 19 }
{
"_id"
: ObjectId(
"592c2e01c070fc0df2f50f1d"
),
"x"
: 20 }
Type
"it"
for
more
> db.winnerdb.winne.remove({x:20})
> db.winedb.winne.
find
({x:20})
删除全部
db.winner.remove()
db.winner.
find
()
show tables;
#检查集合 或者使用show collections
system.indexes
win_collection
winer
winner
由于MongoDB里面的集合不像MySQL里面的表还有结构什么的，所以当我们删除所有数据时，可以直接
删除整个集合，当下次插入数据时，又会创建一个新的集合。
db.winner.drop()
>
for
(i=0;i<100;i++)db.winner.insert({x:i})
for
(i=0;i<100;i++)db.winner.insert({x:i})
> db.winner.
find
()db.winner.
find
()
{
"_id"
: ObjectId(
"592c34bd17c668d64f637dab"
),
"x"
: 25 }
{
"_id"
: ObjectId(
"592c34bd17c668d64f637dac"
),
"x"
: 26 }
{
"_id"
: ObjectId(
"592c34bd17c668d64f637dad"
),
"x"
: 27 }
{
"_id"
: ObjectId(
"592c34bd17c668d64f637dae"
),
"x"
: 28 }
{
"_id"
: ObjectId(
"592c34bd17c668d64f637daf"
),
"x"
: 29 }
{
"_id"
: ObjectId(
"592c34bd17c668d64f637db0"
),
"x"
: 30 }
{
"_id"
: ObjectId(
"592c34bd17c668d64f637db1"
),
"x"
: 31 }
> db.winner.drop()
true
> db.winner.
find
()
> show tables;
system.indexes
win_collection
winer
经过对比，已经删除了之前的集合，但是这样的删除不会影响我们后面插入数据。
|
|
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
|
删除重复文档中的一条文档
定义变量
SQLNAME=({
"titile"
:
"MongoDB学习实践"
,
description:
"MongoDB是NoSQL数据库"
,
by:
"书籍学习"
})
增加数据：
>db.winner2.insert(SQLNAME)
>db.winner2.insert(SQLNAME)
>db.winner2.insert(SQLNAME)
>db.winner2.
find
()
#检查所有的数据
{
"_id"
: ObjectId(
"592c3628c1e073e087a335ee"
),
"titile"
:
"MongoDB学习实践"
,
"description"
:
"MongoDB是NoSQL数据库"
,
"by"
:
"书籍学习"
}
{
"_id"
: ObjectId(
"592c362ac1e073e087a335ef"
),
"titile"
:
"MongoDB学习实践"
,
"description"
:
"MongoDB是NoSQL数据库"
,
"by"
:
"书籍学习"
}
{
"_id"
: ObjectId(
"592c3639c1e073e087a335f0"
),
"titile"
:
"MongoDB学习实践"
,
"description"
:
"MongoDB是NoSQL数据库"
,
"by"
:
"书籍学习"
}
>
执行删除
db.winner2.remove({
"titile"
:
"MongoDB学习实践"
})
再次检查 所有的结果全部删除
db.winner2.
find
()
>
结合前面的语法
db.winner2.remove({
"titile"
:
"MongoDB学习实践"
},1) 再查看数据只删除了其中的一部分
db.winner2.
find
()
{
"_id"
: ObjectId(
"592c391b30de16129bcc9310"
),
"titile"
:
"MongoDB学习实践"
,
"description"
:
"MongoDB是NoSQL数据库"
,
"by"
:
"书籍学习"
}
{
"_id"
: ObjectId(
"592c391c30de16129bcc9311"
),
"titile"
:
"MongoDB学习实践"
,
"description"
:
"MongoDB是NoSQL数据库"
,
"by"
:
"书籍学习"
}
|
2.3.4 更改数据
MySQL中更改数据主要通过update table set where之类的语句实现，做一个简单的示例，不做详细的描述。
|
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
|
mysql>
select
* from winner2;
+----+--------+-----+-----+
|
id
| name | age | sex |
+----+--------+-----+-----+
| 1 | MySQL | 20 | 1 |
| 2 | MySQL | 20 | 1 |
| 3 | Docker | 8 | 0 |
| 4 | MySQL | 20 | 1 |
| 5 | Docker | 8 | 0 |
+----+--------+-----+-----+
5 rows
in
set
(0.00 sec)
mysql> update winner2
set
name=
"MySQLDBA"
where
id
=2;
#将id为2的name更改为MySQLDBA
Query OK, 1 row affected (0.03 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql>
select
* from winner2;
+----+----------+-----+-----+
|
id
| name | age | sex |
+----+----------+-----+-----+
| 1 | MySQL | 20 | 1 |
| 2 | MySQLDBA | 20 | 1 |
| 3 | Docker | 8 | 0 |
| 4 | MySQL | 20 | 1 |
| 5 | Docker | 8 | 0 |
+----+----------+-----+-----+
5 rows
in
set
(0.00 sec)
|
MongoDB中的数据更改也是通过update() 和 save() 实现的，需要注意的是，update()默认更改适合条件的一条文档记录。
update() 和 save()
update() 方法用于更新已存在的文档。语法格式如下：
|
1
2
3
4
5
6
7
8
9
|
db.collection.update(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>,
writeConcern: <document>
}
)
|
参数说明：
query : update的查询条件，类似sql update查询内where后面的。
update : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
writeConcern :可选，抛出异常的级别。
save() 方法
|
1
2
3
4
5
6
7
|
save() 方法通过传入的文档来替换已有文档。语法格式如下：
db.collection.save(
<document>,
{
writeConcern: <document>
}
)
|
参数说明：
document : 文档数据。
writeConcern :可选，抛出异常的级别。
更多实例
只更新第一条记录：
|
1
2
3
4
5
6
7
8
9
10
11
|
db.col.update( {
"count"
: { $gt : 1 } } , { $
set
: {
"test2"
:
"OK"
} } );
全部更新：
db.col.update( {
"count"
: { $gt : 3 } } , { $
set
: {
"test2"
:
"OK"
} },
false
,
true
);
只添加第一条：
db.col.update( {
"count"
: { $gt : 4 } } , { $
set
: {
"test5"
:
"OK"
} },
true
,
false
);
全部添加加进去:
db.col.update( {
"count"
: { $gt : 5 } } , { $
set
: {
"test5"
:
"OK"
} },
true
,
true
);
全部更新：
db.col.update( {
"count"
: { $gt : 15 } } , { $inc : {
"count"
: 1} },
false
,
true
);
只更新第一条记录：
db.col.update( {
"count"
: { $gt : 10 } } , { $inc : {
"count"
: 1} },
false
,
false
);
|
本文转自 tianya1993 51CTO博客，原文链接：http://blog.51cto.com/dreamlinux/1930639，如需转载请自行联系原作者
