参考
https://www.cnblogs.com/moss_tan_jun/p/10074032.html
传统的关系数据库一般由数据库（database）、表（table）、记录（record）三个层次概念组成，MongoDB是由数据库（database）、集合（collection）、文档对象（document）三个层次组成。MongoDB对于关系型数据库里的表，但是集合中没有列、行和关系概念，这体现了模式自由的特点。
| MySQL | MongoDB | 说明 |
| mysqld | mongod | 服务器守护进程 |
| mysql | mongo | 客户端工具 |
| mysqldump | mongodump | 逻辑备份工具 |
| mysql | mongorestore | 逻辑恢复工具 |
| db.repairDatabase() | 修复数据库 | |
| mysqldump | mongoexport | 数据导出工具 |
| source | mongoimport | 数据导入工具 |
| grant * privileges on *.* to … | Db.addUser() Db.auth() | 新建用户并权限 |
| show databases | show dbs | 显示库列表 |
| Show tables | Show collections | 显示表列表 |
| Show slave status | Rs.status | 查询主从状态 |
| Create table users(a int, b int) | db.createCollection("mycoll", {capped:true, size:100000}) 另：可隐式创建表。 | 创建表 |
| Create INDEX idxname ON users(name) | db.users.ensureIndex({name:1}) | 创建索引 |
| Create INDEX idxname ON users(name,ts DESC) | db.users.ensureIndex({name:1,ts:-1}) | 创建索引 |
| Insert into users values(1, 1) | db.users.insert({a:1, b:1}) | 插入记录 |
| Select a, b from users | db.users.find({},{a:1, b:1}) | 查询表 |
| Select * from users | db.users.find() | 查询表 |
| Select * from users where age=33 | db.users.find({age:33}) | 条件查询 |
| Select a, b from users where age=33 | db.users.find({age:33},{a:1, b:1}) | 条件查询 |
| select * from users where age<33 | db.users.find({'age':{$lt:33}}) | 条件查询 |
| select * from users where age>33 and age<=40 | db.users.find({'age':{$gt:33,$lte:40}}) | 条件查询 |
| select * from users where a=1 and b='q' | db.users.find({a:1,b:'q'}) | 条件查询 |
| select * from users where a=1 or b=2 | db.users.find( { $or : [ { a : 1 } , { b : 2 } ] } ) | 条件查询 |
| select * from users limit 1 | db.users.findOne() | 条件查询 |
| select * from users where name like "%Joe%" | db.users.find({name:/Joe/}) | 模糊查询 |
| select * from users where name like "Joe%" | db.users.find({name:/^Joe/}) | 模糊查询 |
| select count(1) from users | Db.users.count() | 获取表记录数 |
| select count(1) from users where age>30 | db.users.find({age: {'$gt': 30}}).count() | 获取表记录数 |
| select DISTINCT last_name from users | db.users.distinct('last_name') | 去掉重复值 |
| select * from users ORDER BY name | db.users.find().sort({name:-1}) | 排序 |
| select * from users ORDER BY name DESC | db.users.find().sort({name:-1}) | 排序 |
| EXPLAIN select * from users where z=3 | db.users.find({z:3}).explain() | 获取存储路径 |
| update users set a=1 where b='q' | db.users.update({b:'q'}, {$set:{a:1}}, false, true) | 更新记录 |
| update users set a=a+2 where b='q' | db.users.update({b:'q'}, {$inc:{a:2}}, false, true) | 更新记录 |
| delete from users where z="abc" | db.users.remove({z:'abc'}) | 删除记录 |
| db. users.remove() | 删除所有的记录 | |
| drop database IF EXISTS test; | use test db.dropDatabase() | 删除数据库 |
| drop table IF EXISTS test; | db.mytable.drop() | 删除表/collection |
| db.addUser(‘test', 'test') | 添加用户 readOnly-->false | |
| db.addUser(‘test', 'test', true) | 添加用户 readOnly-->true | |
| db.addUser("test","test222") | 更改密码 | |
| db.system.users.remove({user:"test"}) 或者db.removeUser('test') | 删除用户 | |
| use admin | 超级用户 | |
| db.auth(‘test', ‘test') | 用户授权 | |
| db.system.users.find() | 查看用户列表 | |
| show users | 查看所有用户 | |
| db.printCollectionStats() | 查看各collection的状态 | |
| db.printReplicationInfo() | 查看主从复制状态 | |
| show profile | 查看profiling | |
| db.copyDatabase('mail_addr','mail_addr_tmp') | 拷贝数据库 | |
| db.users.dataSize() | 查看collection数据的大小 | |
| db. users.totalIndexSize() | 查询索引的大小 |
mongodb语法
MongoDB的好处挺多的，比如多列索引，查询时可以用一些统计函数，支持多条件查询，但是目前多表查询是不支持的，可以想办法通过数据冗余来解决多表查询的问题。
MongoDB对数据的操作很丰富，下面做一些举例说明，内容大部分来自官方文档，另外有部分为自己理解。
查询colls所有数据
db.colls.find() //select * from colls
通过指定条件查询
db.colls.find({‘last_name': ‘Smith'});//select * from colls where last_name='Smith'
指定多条件查询
db.colls.find( { x : 3, y : “foo” } );//select * from colls where x=3 and y='foo'
指定条件范围查询
db.colls.find({j: {$ne: 3}, k: {$gt: 10} });//select * from colls where j!=3 and k>10
查询不包括某内容
db.colls.find({}, {a:0});//查询除a为0外的所有数据
支持<, <=, >, >=查询，需用符号替代分别为$lt，$lte，$gt，$gte
db.colls.find({ “field” : { $gt: value } } );
db.colls.find({ “field” : { $lt: value } } );
db.colls.find({ “field” : { $gte: value } } );
db.colls.find({ “field” : { $lte: value } } );
也可对某一字段做范围查询
db.colls.find({ “field” : { $gt: value1, $lt: value2 } } );
不等于查询用字符$ne
db.colls.find( { x : { $ne : 3 } } );
in查询用字符$in
db.colls.find( { “field” : { $in : array } } );
db.colls.find({j:{$in: [2,4,6]}});
not in查询用字符$nin
db.colls.find({j:{$nin: [2,4,6]}});
取模查询用字符$mod
db.colls.find( { a : { $mod : [ 10 , 1 ] } } )// where a % 10 == 1
$all查询
db.colls.find( { a: { $all: [ 2, 3 ] } } );//指定a满足数组中任意值时
$size查询
db.colls.find( { a : { $size: 1 } } );//对对象的数量查询，此查询查询a的子对象数目为1的记录
$exists查询
db.colls.find( { a : { $exists : true } } ); // 存在a对象的数据
db.colls.find( { a : { $exists : false } } ); // 不存在a对象的数据
$type查询$type值为bsonhttp://bsonspec.org/数 据的类型值
db.colls.find( { a : { $type : 2 } } ); // 匹配a为string类型数据
db.colls.find( { a : { $type : 16 } } ); // 匹配a为int类型数据
使用正则表达式匹配
db.colls.find( { name : /acme.*corp/i } );//类似于SQL中like
内嵌对象查询
db.colls.find( { “author.name” : “joe” } );
1.3.3版本及更高版本包含$not查询
db.colls.find( { name : { $not : /acme.*corp/i } } );
db.colls.find( { a : { $not : { $mod : [ 10 , 1 ] } } } );
sort()排序
db.colls.find().sort( { ts : -1 } );//1为升序2为降序
limit()对限制查询数据返回个数
db.colls.find().limit(10)
skip()跳过某些数据
db.colls.find().skip(10)
snapshot()快照保证没有重复数据返回或对象丢失
count()统计查询对象个数
db.students.find({‘address.state' : ‘CA'}).count();//效率较高
db.students.find({‘address.state' : ‘CA'}).toArray().length;//效率很低
group()对查询结果分组和SQL中group by函数类似
distinct()返回不重复值
==========
由于公司系统使用MongoDB，虽然之前了解，但并没有深入学习MongoDB。见此机会，参考《MongoDB 权威指南》深入学习，结合对比MySQL，加深对两种不同数据库的理解。特把学习过程记录和大家分享。
一、 表结构对比
| 表结构对比 | MongoDB | MySQL |
|---|---|---|
| 表 | collections | tables |
| 行 | documents | rows |
| 主键 | _id | id 与业务无关的值作为主键。如果没有显式地在表定义时指定主键，InnoDB存储引擎会为每一行生成一个6字节的ROWID |
| 主键生成策略 | 24位的字符串(time + machine + pid + inc),自己指定 | UUID, 自增 |
| 面向Documents数据库 | T | F |
| 面向行数据库 | F | T |
| 约束 | 无 | 主键约束，外键约束 |
二、 数据类型对比
| 数据类型对比 | MongoDB | MySQL |
|---|---|---|
| 整形 | NumberInt("3"),NumberLong("3") | TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT |
| 浮点 | 默认使用64位浮点型数值 | FLOAT, DOUBLE, DECIMAL |
| 字符 | utf8 字符串 | VARCHAR, CHAR |
| 日期/时间 | new Date(), 自新纪元依赖经过的毫秒数，不存储时区 | DATE, DATETIME, TIMESTAMP |
| NULL | null | 不支持（null与null不相等） |
| 布尔类型 | true/false | 不支持 |
| 正则表达式 | 支持 { "x" : /foobar/i } | 不支持 |
| 数组 | 支持 { "x" : ["a", "b", "c"]} | 不支持 |
| 二进制数据 | 支持 GridFS | BLOB, TEXT |
| 代码片段 | { "x" : function() { /... / } } | 不支持 |
三、 SHELL终端对比
| 对比项 | MongoDB | MySQL |
|---|---|---|
| 启动 | mongo | mysql -u root -p |
| 查看库 | show dbs | show databases |
| 使用库 | use test | use test |
| 查看表 | show collections | show tables |
四、 查询对比
| 查询对比 | MongoDB | MySQL |
|---|---|---|
| 检索单列 | db.users.find({ "age" : 27 }) | SELECT * FROM users WHERE age = 27; |
| 检索多列 | db.users.find({ "age" : 27, "username" : "joe" }) | SELECT * FROM users WHERE age = 27 and username = 'joe'; |
| 指定需要返回的键 | db.users.find({}, { "username" : 1, "email" : 1 }) | SELECT username, email FROM users; |
| 范围检索 | db.users.find({"age" : { "$gte" : 18, "$lte" : 30 }}) $lt, $lte, $gt, $gte 分别对应 <, <=, >, >= | SELECT * FROM users WHERE age >= 18 AND age <=30; |
| 不匹配检索 | db.users.find({ "username" : { "$ne" : "joe" } }) | SELECT * FROM users WHERE username <> 'joe'; |
| IN 操作符 | db.raffle.find({ "ticket_no" : { "$in" : [725, 542, 390] } }) $in非常灵活，可以指定不同类型 的条件和值。 例如在逐步将用户的ID号迁移成用户名的过程中， 查询时需要同时匹配ID和用户名 | SELECT ticket_no FROM raffles WHERE ticket_no IN (725, 542, 390); |
| NOT IN 操作符 | db.raffle.find({ "ticket_no" : { "$nin" : [725, 542, 390] } }) | SELECT * FROM raffles WHERE ticket_no not in (725, 542, 390); |
| OR 操作符 | db.raffle.find({ "$or" : [{ "ticket_no" : 725 }, { "winner" : true }] }) | SELECT * FROM raffles WHERE ticket_no = 725 OR winner = 'true'; |
| 空值检查 | db.c.find({"y" : null}) null不仅会匹配某个键的值为null的文档 ，而且还会匹配不包含这个键的文档。 所以，这种匹配还会返回缺少这个键的所有文档。 如果 仅想要匹配键值为null的文档， 既要检查改建的值是否为null, 还要通过 $exists 条件 判定键值已经存在 db.c.find({ "z" : { "$in" : [null], "$exists" : true }}) | SELECT * FROM cs WHERE z is null; |
| 多列排序 | db.c.find().sort({ username : 1, age: -1 }) | SELECT * FROM cs ORDER BY username ASC, age DESC; |
| AND操作符 | db.users.find({ "$and" : [{ "x" : { "$lt" : 1 }, { "x" : 4 } }] }) 由于查询优化器不会对 $and进行优化， 所以可以改写成下面的 db.users.find({ "x" : { "$lt" : 1, "$in" : [4] } }) | SELECT * FROM users WHERE x > 1 AND x IN (4); |
| NOT 操作符 | db.users.find({ "id_num" : { "$not" : { "$mod" : [5,1] } } }) | SELECT * FROM users WHERE id_num NOT IN (5,1); |
| LIKE 操作符(正则匹配) | db.blogs.find( { "title" : /post?/i } ) MongoDB 使用Perl兼容的正则表达式(PCRE) 库来匹配正则表达式， 任何PCRE支持表达式的正则表达式语法都能被MongoDB接受 | SELECT * FROM blogs WHERE title LIKE "post%"; |
五、 函数对比
{ "_id" : 1, "item" : "abc", "price" : 10, "quantity" : 2 }
{ "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1 }
{ "_id" : 3, "item" : "xyz", "price" : 5, "quantity" : 5 }
{ "_id" : 4, "item" : "abc", "price" : 10, "quantity" : 10 }
{ "_id" : 5, "item" : "xyz", "price" : 5, "quantity" : 10 }
| 函数对比 | MongoDB | MySQL |
|---|---|---|
| COUNT | db.foo.count() | SELECT COUNT(id) FROM foo; |
| DISTINCT | db.runCommand({ "distinct": "people", "key": "age" }) | SELECT DISTINCT(age) FROM people; |
| MIN | db.sales.aggregate( [ { $group: { _id: {}, minQuantity: { $min: "$quantity" } } } ]); 结果： { "_id" : { }, "minQuantity" : 1 } | SELECT MIN(quantity) FROM sales; |
| MAX | db.sales.aggregate( [ { $group: { _id: {}, maxQuantity: { $max: "$quantity" } } } ]); | SELECT MAX(quantity) FROM sales; |
| AVG | db.sales.aggregate( [ { $group: { _id: {}, avgQuantity: { $avg: "$quantity" } } } ]); | SELECT AVG(quantity) FROM sales; |
| SUM | db.sales.aggregate( [ { $group: { _id: {}, totalPrice: { $sum: "$price" } } } ]); | SELECT SUM(price) FROM sales; |
六、 CURD 对比
| CURD 对比 | MongoDB | MySQL |
|---|---|---|
| 插入数据 | post = {"title" : "My Blog Post", "content" : "Here`s my blog post"}; db.blog.insert(post) 如果blog 这个集合不存在，则会创建 | INSERT INTO blogs(title, blog_content) VALUES ('My Blog Post', 'Here`s my blog post.') |
| 批量插入 | db.blog.batchInsert([{ "title" : "AAA", "content" : "AAA---" }, { "title" : "BBB", "content" : "JJJJ--" }]) 当前版本的MongoDB能接受最大消息长度48MB， 所以在一次批量插入中能插入的文档是有限制的。 并且在执行批量插入的过程中，有一个文档插入失败， 那么在这个文档之前的所有文档都会成功插入到集合中， 而这个文档以及之后的所有文档全部插入失败。 | INSERT INTO blogs(title, blog_content) VALUES('AAA', 'AAA---'), ('BBB', 'BBB---'); |
| 查询数据 | db.blog.find(); db.blog.findOne(); | SELECT * FROM blogs; SELECT * FROM blogs LIMIT 1; |
| 更新旧数据 | post.blog_content = "十一"; db.blog.update({title: "My Blog Post"}, post) | UPDATE set blog_content = "十一" WHERE title = "My Blog Post"; |
| 更新新增COLUMN | post.comments = "very good"; db.blog.update({title : "My Blog Post"}, post) | ALTER table blogs ADD COLUMN comments varchar(200); UPDATE blogs set comments = "very good" WHERE title = 'My Blog Post'; |
| 删除数据 | db.blog.remove({ title : "My Blog Post" }) | DELETE FROM blogs WHERE title = 'My Blog Post' |
| 校验 | post.blog_visit = 123; db.blog.update({title : "My Blog Post"}, post); post.blog_visit = "asd.123aaa"; db.blog.update({title : "My Blog Post"}, post) 插入的时候，检查大小。所有的文档都必须小于16MB。 这样做的目的是为了防止不良的模式设计，并且保持性能一直。由于MongoDB只进行最基本的检查，所以插入非法的数据很容易。 | 类型校验，长度校验。 ALTER table blogs ADD COLUMN blog_visit INT(10); UPDATE blogs SET blog_visit = "asdasd" WHERE id = 1; ERROR 1366 (HY000): Incorrect integer value: 'asdasd' for column 'blog_visit' at row 1 |
| 删除表 | db.blog.remove({}), db.blog.drop() | DELETE from blogs; drop table blogs; |
分类: mongdb
MySQL与MongoDB对比
https://blog.csdn.net/m0_37686205/article/details/90722956
MongoDB场景使用场景？
MongoDB是用于各种用例的通用数据库。 MongoDB最常见的用例包括单视图，物联网，移动，实时分析，个性化，目录和内容管理。
何时用MySQL比较合适
虽然大多数现代应用程序需要一个灵活的可扩展系统，如MongoDB，但是有一些关系数据库（如MySQL）将更适合使用的情况。需要复杂的多行事务的应用程序（例如双记录bookkeep系统）将是很好的例子。 MongoDB不是围绕关系数据模型和SQL构建的遗留应用程序的替代方法。
一个具体的例子是旅行预订系统背后的预订引擎，通常还涉及复杂的事务。虽然核心预订引擎可能在MySQL上运行，但是与用户互动的应用程序部分 - 提供内容，与社交网络集成，管理会话 - 将更好地放在MongoDB中
MongoDB和MySQL能否一块使用？
MongoDB和MySQL的混合部署有很多例子。在某些情况下，这是一个使用合适工具的的问题。例如，许多电子商务应用程序使用MongoDB和MySQL的组合。产品目录包括具有不同属性的多个产品，非常适合MongoDB的灵活数据模型。另一方面，需要复杂事务的结帐系统可能建立在MySQL或其他关系数据库技术上。
在其他情况下，新的业务需求推动企业采用MongoDB作为其应用程序的下一代组件。例如，世界领先的业务管理软件和服务供应商之一的Sage集团将MongoDB整合到其适用于中型企业的受欢迎的企业资源规划（ERP）解决方案中。 Sage客户现在享受更高程度的功能和个性化作为一体化的结果。虽然许多Sage产品最初建立在MySQL上并继续运行，但最新的用户体验功能集中在MongoDB周围。
除了这几个例外，我们认为，由于其灵活的数据模型和可扩展架构，MongoDB几乎总是比MySQL更好的选择。
https://www.cnblogs.com/williamjie/p/9499853.html
1. 数据库的平均插入速率：MongoDB不指定_id插入 > MySQL不指定主键插入 > MySQL指定主键插入 > MongoDB指定_id插入。
2. MongoDB在指定_id与不指定_id插入时速度相差很大，而MySQL的差别却小很多。
分析：
1. 在指定_id或主键时，两种数据库在插入时要对索引值进行处理，并查找数据库中是否存在相同的键值，这会减慢插入的速率。
2. 在MongoDB中，指定索引插入比不指定慢很多，这是因为，MongoDB里每一条数据的_id值都是唯一的。当在不指定_id插入数据的时候，其_id是系统自动计算生成的。MongoDB通过计算机特征值、时间、进程ID与随机数来确保生成的_id是唯一的。而在指定_id插入时，MongoDB每插一条数据，都需要检查此_id可不可用，当数据库中数据条数太多的时候，这一步的查询开销会拖慢整个数据库的插入速度。
3. MongoDB会充分使用系统内存作为缓存，这是一种非常优秀的特性。我们的测试机的内存有64G，在插入时，MongoDB会尽可能地在内存快写不进去数据之后，再将数据持久化保存到硬盘上。这也是在不指定_id插入的时候，MongoDB的效率遥遥领先的原因。但在指定_id插入时，当数据量一大内存装不下时，MongoDB就需要将磁盘中的信息读取到内存中来查重，这样一来其插入效率反而慢了。
4. MySQL不愧是一种非常稳定的数据库，无论在指定主键还是在不指定主键插入的情况下，其效率都差不了太多。
插入稳定性分析
插入稳定性是指，随着数据量的增大，每插入一定量数据时的插入速率情况。
在本次测试中，我们把这个指标的规模定在10w，即显示的数据是在每插入10w条数据时，在这段时间内每秒钟能插入多少条数据。
先呈现四张图上来：
1. MongoDB指定_id插入：
2. MongoDB不指定_id插入：
3. MySQL指定PRIMARY KEY插入：
4. MySQL不指定PRIMARY KEY插入：
总结：
1. 整体上的插入速度还是和上一回的统计数据类似：MongoDB不指定_id插入 > MySQL不指定主键插入 > MySQL指定主键插入 > MongoDB指定_id插入。
2. 从图中可以看出，在指定主键插入数据的时候，MySQL与MongoDB在不同数据数量级时，每秒插入的数据每隔一段时间就会有一个波动，在图表中显示成为规律的毛刺现象。而在不指定插入数据时，在大多数情况下插入速率都比较平均，但随着数据库中数据的增多，插入的效率在某一时段有瞬间下降，随即又会变稳定。
3. 整体上来看，MongoDB的速率波动比MySQL的严重，方差变化较大。
4. MongoDB在指定_id插入时，当插入的数据变多之后，插入效率有明显地下降。在其他三种的插入测试中，从开始到结束，其插入的速率在大多数的时候都固定在一个标准上。
分析：
1. 毛刺现象是因为，当插入的数据太多的时候，MongoDB需要将内存中的数据写进硬盘，MySQL需要重新分表。这些操作每当数据库中的数据达到一定量级后就会自动进行，因此每隔一段时间就会有一个明显的毛刺。
2. MongoDB毕竟还是新生事物，其稳定性没有已应用多年的MySQL优秀。
3. MongoDB在指定_id插入的时候，其性能的下降还是很厉害的。
1. 在读取的数据规模不大时，MongoDB的查询速度真是一骑绝尘，甩开MySQL好远好远。
2. 在查询的数据量逐渐增多的时候，MySQL的查询速度是稳步下降的，而MongoDB的查询速度却有些起伏。
分析：
1. 如果MySQL没有经过查询优化的话，其查询速度就不要跟MongoDB比了。MongoDB可以充分利用系统的内存资源，我们的测试机器内存是64GB的，内存越大MongoDB的查询速度就越快，毕竟磁盘与内存的I/O效率不是一个量级的。
2. 本次实验的查询的数据也是随机生成的，因此所有待查询的数据都存在MongoDB的内存缓存中的概率是很小的。在查询时，MongoDB需要多次将内存中的数据与磁盘进行交互以便查找，因此其查询速率取决于其交互的次数。这样就存在这样一种可能性，尽管待查询的数据数目较多，但这段随机生成的数据被MongoDB以较少的次数从磁盘中取出。因此，其查询的平均速度反而更快一些。这样看来，MongoDB的查询速度波动也处在一个合理的范围内。
3. MySQL的稳定性还是毋庸置疑的。
结论
1. 相比较MySQL，MongoDB数据库更适合那些读作业较重的任务模型。MongoDB能充分利用机器的内存资源。如果机器的内存资源丰富的话，MongoDB的查询效率会快很多。
2. 在带”_id”插入数据的时候，MongoDB的插入效率其实并不高。如果想充分利用MongoDB性能的话，推荐采取不带”_id”的插入方式，然后对相关字段作索引来查询。
1. MongoDB适合那些对数据库具体数据格式不明确或者数据库数据格式经常变化的需求模型，而且对开发者十分友好。
2. MongoDB官方就自带一个分布式文件系统，可以很方便地部署到服务器机群上。MongoDB里有一个Shard的概念，就是方便为了服务器分片使用的。每增加一台Shard，MongoDB的插入性能也会以接近倍数的方式增长，磁盘容量也很可以很方便地扩充。
3. MongoDB还自带了对map-reduce运算框架的支持，这也很方便进行数据的统计。
MongoDB的缺陷
1. 事务关系支持薄弱。这也是所有NoSQL数据库共同的缺陷，不过NoSQL并不是为了事务关系而设计的，具体应用还是很需求。
2. 稳定性有些欠缺，这点从上面的测试便可以看出。
3. MongoDB一方面在方便开发者的同时，另一方面对运维人员却提出了相当多的要求。业界并没有成熟的MongoDB运维经验，MongoDB中数据的存放格式也很随意，等等问题都对运维人员的考验。
分类: mgo
大数据环境下mongoDB要加索引
https://www.cnblogs.com/lori/p/10880967.html
1416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
