NoSQL基础部分

一、NoSQL相关概念

1、NoSQL定义

Not only SQL

2、时间单位

1s=10^3 ms=10^6 um=10^9 ns

3、存储数据单位

B、KB、MB、TB、PB、EB、ZB、YB

二、数据库分类

1、TRDB数据库

2、NoSQL数据库

1. 键值数据库
2. 文档数据库
3. 列族数据库
4. 图数据库
5. 其他数据库

3、NewSQL

三、

1、帽子定理

• 一致性
• 可用性
• 分区容错性

2、ACID

• 原子性
• 一致性
• 隔离性
• 持久性

3、BASE

• 基本可用
• 软状态
• 最终一致性

四、NoSQL存储模式

1、键值数据存储模式

基本要素：键、值、键值对、命名空间

操作：读、写、删除

优点：简单、快速、高效计算

缺点：对值进行多值查找功能很弱；缺少约束，意味着更容易出错；不容易建立复杂关系

2、文档数据存储模式

基本要素：键值对、文档、集合、数据库

操作：增删改查

优点：简单；相对高效；文档格式处理；查询功能强大；分布式处理

缺点：缺少约束；数据出现冗余；相对低效

3、列族数据存储模式

基本要素：命名空间、行键、列族、列

操作：读、写、删除

特点：擅长大数据处理；对于命名空间、行键、列族需要预先定义，列无须提早定义，随时可以增加；在大数据应用环境下，管理复杂，必须借助各种高效的管理工具来监控系统的正常运行；Hadoop生态系统为基于列族的大数据分析，提供了各种开发工具；数据存储模式相对键值数据库、文档数据库要复杂；查询功能相对更加丰富；高密集写入处理能力 每秒几百万次的并发插入能力

4、图数据存储模式

基本要素：节点、边、属性、图

操作：建立、删除、更新、合并

特点；处理各种具有图结构的数据；应用领域明确；以单台服务器运行的图数据库为主；图偏重于查找、统计、分析应用

5、其他数据存储模式

1、多模式数据库

2、对象数据库

3、网格和云数据库

NoSQL实践部分

一、MongoDB shell简单操作

1、启动

mongo

mongo 127.0.0.1:27017/admin

2、退出

exit

3、创建数据库

use 数据库名

4、查看数据库

show dbs

5、查看当前数据库中的集合列表

show collections

6、统计当前数据库信息

db.stats()

7、删除当前数据库

db.dropDatabase()

8、帮助指令

# 数据库操作
db.help()
# 集合操作
db.集合名.help()
# 文档操作
db.集合名.find().help()

9、查看当前数据库下集合名称

db.getCollectionNames()

10、查看数据库用户角色权限

show roles

11、执行js文件

mongo shell_script.js

load(script_path)

二、配置用户账号和访问控制

1、角色概念

1. 数据库用户角色：read、readWrite
2. 数据库管理角色：dbAdmin、dbOwner、userAdmin
3. 集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager
4. 备份恢复角色：backup、restore
5. 所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
6. 超级用户角色：root
7. 内部角色：_system

read：允许用户读取指定数据库

readWrite：允许用户读写指定数据库

dbAdmi：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile

userAdmin：允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户

clusterAdmin：只在admin数据库中可用，具有所有分片和复制集相关函数的管理权限。

readAnyDatabase：只在admin数据库中可用，具有所有数据库的读权限

readWriteAnyDatabase：只在admin数据库中可用，具有所有数据库的读写权限

userAdminAnyDatabase：只在admin数据库中可用，具有所有数据库的userAdmin权限

dbAdminAnyDatabase：只在admin数据库中可用，具有所有数据库的dbAdmin权限。

root：只在admin数据库中可用。超级账号，超级权限

2、用户操作

创建用户

use admin
db.createUser({
	user: 'root',
	pwd: 'root',
	roles: [{"role": "root", "db": "admmin"}]
})
exit

认证登录

mongo
use admin
db.auth('root','root')

mongo admin -u root -p root

删除用户

use admin
db.dropUser("root")

三、管理数据库和集合

1、给指定数据库添加集合并添加文档

db.集合名.insert({key:value})

2、删除指定数据库中的集合

db.集合名.drop()

3、查询指定集合中的文档

db.集合名.find()
db.集合名.findOne()

4、更新文档

db.集合名.update({key:value},{$set:{key:value}})

5、删除文档

db.集合名.remove({key:value})

四、Find详细内容

1、语法

db.[Collection_Name].find({query},{projection})
db.[Collection_Name].find({query},{projection}).pretty() // 规整查找结果的格式

• query //查询条件设置：查询选择器
• projection //键指定，指定需要返回的字段：投影操作

2、查询选择器

（1）选择器匹配

db.[Collection_Name].find({<key1:value1>,{<key2:value2>,...}})

注意：无论传入多少个键值对它们必须全部匹配；查询条件之间相当于运用了布尔运算符and。

（2）范围查询

操作符	意义	符合
$lt	less than	<
$lte	less than or equal	<=
$gt	greater than	>
$gte	greater than or equal	>=

# 查询年龄介于25到30之间的人
db.persons.find({age:{$gte:25,$lte:30}})

（3）匹配数组

操作符	作用
$in	与任一搜索键匹配时，就返回该文档
$nin	与任一搜索键不匹配时，就返回该文档
$elemMatch	至少有一个元素满足所有匹配条件，就返回该文档
$all	与所有搜索键匹配，就返回文档
$size	查询指定长度数组（不能与比较查询符一起使用）

# 查询国籍是（不是）中国或美国的学生信息
db.persons.find({country:{$in:["USA","China"]}})
db.persons.find({country:{$nin:["USA","China"]}})

# 查询 80<=results<=85的文档
db.scores.find({results:{$elemMatch:{$gte:80,$lte:85}}})

# 查询喜欢看MONGODB和JS的学生
db.persons.find({books:{$all:["MONGODB","JS"]}})

# 查询第二本书是JAVA的学生信息
db.persons.find({"books.1":"JAVA"})

# 查询出书籍数量是4的学生
db.persons.find({books:{$size:4}})

（4）布尔查询

操作符	意义	备注
$ne	不等于	可以作用于单个值和数组
$not	对查询结果求反	不能放在外层文档；后面必须跟正则表达式或者文档
$or	逻辑或	条件1尽可能 匹配更多文档
$and	连接具有and关系的复杂查询条件
$exists	查询集合中包含特定键的文档

# 查询国籍不是美国籍的学生信息
db.persons.find({country:{$ne:"USA"}},{_id:0,name:1,country:1})

# 查询出姓名里存在“li”的学生信息
db.persons.find({name:/li/i})
# 查询出姓名里不存在“li”的学生信息
db.persons.find({name:{$not/li/i}})

# 查询语文成绩大于85或者英语大于90的学生信息
db.persons.find({$or:[{c:{gt:85}},{e:{gt:90}}]})

# 查询国籍是中国或美国的学生信息
db.persons.find({$or:[{country:"China"},{country:"USA"}]})
db.persons.find({country:{$or:["China","USA"]}}) // 错误
db.persons.find({country:{$in:["USA","China"]}})

# 返回键名含有gender的文档
db.persons.find({gender:{$exists:true}})
# 返回键名部含有gender的文档
db.persons.find({gender:{$exists:false}})

（5）正则表达式

# $regex
{<field>:{$regex:/pattern/,$options:'<options>'}}
{<field>:{$regex:'pattern',$options:'<options>'}}
{<field>:{$regex:/pattern/<options>}}

# 正则表达式对象
{<field>:/pattern/<options>}

	$in	隐式的$and	options中包含X或S选项时
正则表达式	√
$reges		√	√

{name:{$in:[/^joe/i,/^jack/]}}
{name:{$regex:/^zh/i,$min:["zhang"]}}
{email:{$regex:/@qq./,$options:"si"}}

pattern选项	实例	比较说明
/查询值的固定后一部分$/	db.persons.find({name:{$regex:/ang$/}})	where name like “%ang”
/^查询值的固定前一部分/	db.persons.find({name:{$regex:/^zh/}})	where name like “zh%”
/查询值的任意部分/	db.persons.find({name:{$regex:/c/}})	where name like “%c%”

options选项	语法格式	选项说明
i	{<field>{$regex:/pattern/i}}	不区分大小写字母
m	{<field>:{$regex:/pattern/,$options:m}}	多行匹配模式
x	{<field>:{$regex:/pattern/,$options:x}}	忽略非转义的空白字符
s	{<field>:{$regex:/pattern/,$options:s}}	单行匹配模式

（6）where操作符

// 查询年龄大于22岁，喜欢看JS书，在八一中学上过学的学生
db.persons.find({"$where":function(){
	var books=this.books;
	var schools=this.schools;
	if(this.age>22){
		for(var i=0;i<books.length;i++){
			if(books[i]=="JS"){
				if(schools){
					for(var j=0;j<schools.length;j++)
						if(schools[j].name=="八一中学"){
							return true;
						}
				}
				break;
			}
		}
	}
}})

（7）Type操作符

3、投影

db.persons.find({},{_id:0,name:1})

# 查询出“lisi”书架上的第2~4本书
db.persons.find({name:"lisi"},{_id:0,name:1,books:{$slice:[1,3]}}) # 1：跳过元素数，2：返回元素数

# 查询出“lisi”书架上的最后一本书
db.persons.find({name:"lisi"},{_id:0,name:1,books:{$slice:-1}})

4、其他

（1）Limit返回指定的数据条数

# 查询出persons文档中前5条数据
db.persons.find().limit(5)

（2）Skip返回指定数据跨度

# 查询出persons文档中5~10条的数据
db.persons.find().limit(5).skip(5)

（3）Sort按指定属性排序

# 返回按年龄排序的数据
db.persons.find().sort({age:1}) #升序
db.persons.find().sort({age:-1}) #降序

（4）游标

var persons=db.persons.find();
while(persons.hasNext()){
	obj=persons.next();
	print(obj.name)
}

var ShowCursor=db.persons.find()
ShowCursor.forEach(printjson)

（5）Count计数

# 查询美国学生的人数
db.persons.find({country:"USA"}).count()

（6）Distinct查找不同的字段值

# 查询出persons中一共有多少个国家分别是什么
db.persons.distinct("country",{})
db.runCommand({distinct:"persons",key:"country"}).values

五、集合操作

1、插入文档

insert

db.collection_name.insert(<document or array of document>,{writeConcern:<document>,ordered:<boolean>})

db.collection_name.insertOne()
db.collection_name.insertMany()

save

db.collection_name.save(<document>)

2、更新文档

db.collection_name.update(<query>,<update>,{upsert:<boolean>,multi:<boolean>,writrConcern:<document>,collation:<document>})

参数名称
query	update的查询条件
update	update的对象和更新操作符
upsert	如果不存在update的记录是否插入
multi	是否更新多条记录
writerConcern	自定义写出错确认级别
collation	指定特定国家语言的更新归类规则

（1）insertOrUpdate操作

db.collection_name.update({查询器},{修改器},true) # 对应upsert参数

（2）批量更新操作

db.collection_name.update({查询器},{修改器},false,true) # false:对应upsert参数;true:对应multi参数

操作符
$set	修改器
$inc	修改数值，加法
$mul	修改数值，乘法
$rename	修改错误字段的键名
$unset	删除指定字段
$min	当前值大于指定值时，修改为指定值
$max	当前值小于指定值时，修改为指定值
$addToSet	若目标数组值中存在要追加的元素，则该元素不做任何操作
$push	1.如果指定的键是数组，追加新的元素值 2.如果指定的键不是数组，则中断当前操作 3.如果不存在指定的键，则创建数组类型的键值对
$pop	从指定数组删除一 个值: 1删除最后一个数值；-1删除第一个数值
$pull	删除一个被指定的数值
$pullAll	次性删除多个指定的数值

3、删除文档

db.collection_name.remove(<query>,{justOne:<boolean>,writeConcern:<document>,collection:<document>})

六、分组、聚合、映射-归并、复制分片

1、分组

db.runCommand({group:{
	ns:集合名字,
	Key:分组的键对象,
	Initial:初始化累加器,
	$reduce:组分解器,
	Condition:条件,
	Finalize:组完成器
}})

# 查出persons中每个国家学生数学成绩最好的学生信息（必须在90以上）
db.runCommand({group:{
	ns:"persons",
	Key:{"country":true},
	Initial:{m:0},
	$reduce:function(doc,prev){
		if(doc.m>prev.m){
			prev.m=doc.m;
			prev.name=doc.name;
			prev.country=doc.country;
		}
	},
	Condition:{m:{$gt:90}}
	finalize:function(prev){
		prev.m=prev.name+"Math scores"+prev.m
	}
}})

2、聚合

db.collection_name.aggregate({$match:{<field>}},{$group:{<field1>,<field2>}})

field1：分类字段

field2：含各种统计操作符的数值型字段（$sum,$max,$min等）

可在aggregate()中使用的聚合运算符

运算符	描述
$project	通过重命名、添加或删除字段来重新定义文档。
$match
$limit	限制传递给聚合流水线中下一个阶段的文档数
$skip	指定执行聚合流水线的下一个阶段前跳过多少个文档
$unwind	对指定的数组进行分拆，为其中的每一个值创建一个文档
$group	将文档分组并生成一组新的文档，供流水线的下一个阶段使用
$sort

可在聚合运算符$group中使用的表达式运算符

运算符	描述
$addToSet
$first	返回当前文档组中第一个文档的指定字段的值
$last
$max
$min
$avg
$push
$sum

# 查出persons中每个国家学生数学成绩最好的学生信息（必须在90以上）
db.persons.aggregate({$match:{m:{$gte:90}}},{$group:{_id:{country:"$country",name:"$name",value:"$m"}}})

3、映射-归并

db.orders.mapReduce(
	function(){emit(param1,param2);},
	function(key,values){return Array.sum(values);},
	{
		query:{status:"A"}, 
		out:"order_totals"
	}
)

1、map部分

作用：用于分组。

param1：需要分组的字段，this.字段名。

param2：需要进行统计的字段，this.字段名。

2、reduce部分

作用：处理需要统计的字段。

key：指分组字段对应的值。

values：指需要统计的字段值组成的数组。

// 对数值类型进行求和
var reduce=function(key,values){ return Array.sum(values);}
// 对字符串类型进行拼凑
var reduce=function(key,values){ return values.join(',');}

3、options部分

query：先筛选符合条件的记录出来，再进行分组统计。

out：将分组统计后的结果输出到哪个集合中。

# 统计不同地方的人的年龄总和
var map=function(){emit(this.location,this.age);}
var reduce=function(key,valued){return Array.sum(values);}
var options={out:"age_totals"}
db.mythings.mapReduce(map,reduct,options)

# 统计不同地方的人数总和
var map=function(){emit(this.location,1);}
var reduce=function(key,valued){return Array.sum(values);}
var options={out:"person_totals"}
db.mythings.mapReduce(map,reduct,options)

# 统计不同地方的人名列表
var map=function(){emit(this.location,this.name);}
var reduce=function(key,valued){return values.join(',');}
var options={out:"name_totals"}
db.mythings.mapReduce(map,reduct,options)

# 统计不同地方并且年龄在25岁（不包括25岁）以下的人名列表
var map=function(){emit(this.location,this.name);}
var reduce=function(key,valued){return key+':'+values.join(',');}
var options={query:{age:{$lt:25}},out:"name_totals"}
db.mythings.mapReduce(map,reduct,options)

4、复制分片

七、Java连接MongoDB

package com.example.demo;

import com.mongodb.client.*;
import org.bson.Document;


public class JavaConnect {
    public static void main(String[] args) {
        MongoClient mg = MongoClients.create("mongodb://localhost:27017");
        MongoDatabase db = mg.getDatabase("***"); // 数据库名
        MongoCollection<Document> collection = db.getCollection("***");  // 集合名
        FindIterable<Document> findIter = collection.find().limit(10); // 获取文档
        MongoCursor<Document> cur = findIter.iterator(); // 获得迭代器
        System.out.println("该单词库共有："+collection.countDocuments()+"个单词。");
        while (cur.hasNext()) { // 遍历集合
            Document doc = cur.next();
            System.out.println(doc.get("word"));
        }
        mg.close(); // 关闭连接
    }
}

测试题

# 1
mongo member.js
show collections

# 2
db.member.find({},{_id:0})

# 3
db.member.find({age:{$gte:19,$lte:21}},{sno:1,sname:1,age:1,_id:0})

# 4
db.member.find({$or:[{major:"计算机科学与技术"},{major:"网络工程"}]},{sno:1,sname:1,major:1,_id:0})

# 5
db.member.distinct("major")

# 6
db.member.find().count()

# 7
db.member.find({'course.1':"python"},{_id:1,sname:1})

# 8
db.member.find({},{_id:1,sname:1,age:1}).sort({age:-1})

# 9
db.member.update({sname:"zhouyang"},{$set:{sno:"1813007",sname:"zhouyang",age:18,major:"网络工程"}},true)

# 10
db.member.update({major:"软件工程"},{$set:{location:"loc01"}},false,true)
db.member.find()

# 11
db.member.update({sno:"1813003"},{$addToSet:{course:"JSP"}})
db.member.find()

# 12
db.member.remove({major:"通信工程"},{justOne:false})
db.member.find({},{_id:0,sno:1,sname:1,major:1})

# 13
var map=function(){emit(this.major,this.sname);}
var reduce=function(key,values){return key+'>>'+values.join(',');}
var options={out:"stu1"}
db.member.mapReduce(map,reduce,options)
db.stu1.find()

# 14
db.member.aggregate({$match:{age:{$gte:18}}},{$group:{_id:"$major",age_max:{$max:"$age"}}})

1.四种分类

1.key-value

Redis
键值对存储，特点：查询数据块
内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等等。

2.Colunmn列式存储
HBase
将同一列的数据放在一起，查询非常快

3.document文档存储

MongoDB
经典用于web项目中，与KeyValue类似，比如MongoDB主要应用在爬虫

4.Graph图结构存储

neo4j
用于社交网络，

Nosql特点:

1.易扩展

当一台机器不够用了，很容易添加一个新的服务器，只要配置好环境之后，自动使用。

2.大数据量、高性能

读写速度快，nosql基本都是内存数据库，比硬盘存储要快很多，查询数据快

3.灵活性

NoSQL无需事先为 要存储的数据 建立字段，随时可以存储自定义的数据格式，在关系型数据库添加字段和删除字段是非常麻烦的。

4.高可用

一台机器宕机出问题了，不会影响其他的机器

3.相关理论

相关理论
关系数据库理论：ACID
分布式系统：CAP
Consistency (一致性)：

“all nodes see the same data at the same time”,即更新操作成功并返回客户端后，所有节点在同一时间的数据完全一致，这就是分布式的一致性。一致性的问题在并发系统中不可避免，对于客户端来说，一致性指的是并发访问时更新过的数据如何获取的问题。从服务端来看，则是更新如何复制分布到整个系统，以保证数据最终一致。

Availability (可用性):

可用性指“Reads and writes always succeed”，即服务一直可用，而且是正常响应时间。好的可用性主要是指系统能够很好的为用户服务，不出现用户操作失败或者访问超时等用户体验不好的情况。

Partition Tolerance (分区容错性):

即分布式系统在遇到某节点或网络分区故障的时候，仍然能够对外提供满足一致性或可用性的服务。

分区容错性要求能够使应用虽然是一个分布式系统，而看上去却好像是在一个可以运转正常的整体。比如现在的分布式系统中有某一个或者几个机器宕掉了，其他剩下的机器还能够正常运转满足系统需求，对于用户而言并没有什么体验上的影响。
https://blog.csdn.net/qq_34802511/article/details/81296510

第七章-NoSQL数据库

NoSQL简介

传统关系数据库一度占据商业数据库应用的主流位置

• 完备的关系理论基础
• 事务管理机制的支持
• 高效的查询优化机制

但是关系数据库无法满足 Web 2.0和大数据时代的需求

1. 无法满足海量数据的管理需求
2. 无法满足数据高并发的需求
3. 无法满足高可扩展性和高可用性的需求

关系数据库中的关键特性包括完善的事务机制和高效的查询机制在Web 2.0时代没有发挥

1. Web 2.0系统通常不要求严格的数据库事务
2. Web 2.0并不要求严格的读写实时性
3. Web 2.0通常不包含大量复杂的SQL查询（去结构化， 存储空间换取更好的查询性能）

在这样的新的应用背景下，关系数据库实在难以满足要求，于是 NoSQL 数据库就应运而生了。

NoSQL（Not Only SQL）是对非关系型数据库的统称，采用的是类似键/值、列族、文档等非关系模型。

NoSQL数据库没有固定的表结构，通常也不存在连接操作，也没有严格遵守 ACID 约束。和关系型数据库相比，NoSQL具有灵活的水平拓展性，可以支持海量数据的存储。

NoSQL数据库具有以下三个特点：

1. 灵活的可扩展性
2. 灵活的数据模型
3. 与云计算紧密融合

NoSQL VS. 关系数据库

关系数据库

• 优势：以完善的关系代数理论作为基础，有严格的标准，支持事务 ACID，借助索引机制可以实现高效的查询，技术成熟，有专业公司的技术支持
• 劣势：可扩展性较差，无法较好支持海量数据存储，数据模型过于死板、无法较好支持Web2.0应用，事务机制影响了系统的整体性能等

NoSQL数据库

• 优势：可以支持超大规模数据存储，灵活的数据模型可以很好地支持Web2.0应用，具有强大的横向扩展能力等
• 劣势：缺乏数学理论基础，复杂查询性能不高，大都不能实现事务强一致性，很难实现数据完整性，技术不够成熟，缺乏专业团队的 技术支持，维护较困难等

比较标准	关系数据库RDBMS	NoSQL	备注
数据库原理	完全支持	部分支持	RDBMS有关系代数理论作为基础 NoSQL没有统一的理论基础
数据规模	大	超大	RDBMS很难实现横向扩展，纵向扩展的空间也比较有限，性能会随着数据规模的增大而降低 NoSQL可以很容易通过添加更多设备来支持更大规模的数据
数据库模式	固定	灵活	RDBMS需要定义数据库模式，严格遵守数据定义和 相关约束条件 NoSQL不存在数据库模式，可以自由灵活定义并存 储各种不同类型的数据
查询效率	快	可以实现高效的简单查询，但是不具备高度结构化查询等特性，复杂查询的性能不尽人意	RDBMS借助于索引机制可以实现快速查询（包括记 录查询和范围查询） 很多NoSQL数据库没有面向复杂查询的索引
一致性	强一致性	弱一致性	RDBMS严格遵守事务ACID模型，可以保证事务强一致性 很多NoSQL数据库放松了对事务ACID四性的要求， 而是遵守BASE模型，只能保证最终一致性
数据完整性	容易实现	很难实现	任何一个RDBMS都可以很容易实现数据完整性，比如通过主键或者非空约束来实现实体完整性，通过主键、外键来实现参照完整性，通过约束或者触发器来实现用户自定义完整性 但是，在NoSQL数据库却无法实现
扩展性	一般	好	RDBMS很难实现横向扩展，纵向扩展的空间也比较有限 NoSQL在设计之初就充分考虑了横向扩展的需求， 可以很容易通过添加廉价设备实现扩展
可用性	好	很好	RDBMS在任何时候都以保证数据一致性为优先目标，其次才是优化系统性能，随着数据规模的增大，RDBMS为了保证严格的一致性，只能提供相对较弱的可用性 大多数NoSQL都能提供较高的可用性
标准化	是	否	RDBMS已经标准化（SQL） NoSQL还没有行业标准，不同的NoSQL数据库都有自己的查询语言，很难规范应用程序接口
技术支持	高	低	RDBMS经过几十年的发展，已经非常成熟，Oracle 等大型厂商都可以提供很好的技术支持 NoSQL在技术支持方面还不成熟，缺乏有力的技术支持
可维护性	复杂	复杂	RDBMS需要专门的数据库管理员(DBA)维护 NoSQL数据库虽然没有DBMS复杂，也难以维护

关系数据库和NoSQL数据库各有优缺点，彼此无法取代

• 关系数据库应用场景：电信、银行等领域的关键业务系 统，需要保证强事务一致性
• NoSQL数据库应用场景：互联网企业、传统企业的非关 键业务（比如数据分析）

有时候也会采用混合架构，比如使用不同类型的数据库来支撑电子商务应用。

• 对于“购物车”这种临时性数据，采用键值存储会更加高效
• 当前的产品和订单信息则适合存放在关系数据库中
• 大量的历史订单信息则适合保存在类似 MongoDB 的文档数据库中

NoSQL的四大类型

典型的NoSQL数据库通常包括：

• 键值数据库
• 列族数据库
• 文档数据库
• 图形数据库

键值数据库

键值数据库（Key-Value Database）会使用一个哈希表，这个表中有一个特定的 Key 和一个指针指向特定的 Value。Key可以用来定位 Value，即存储和检索具体的 Value。

Value可以用来存储任意类型的数据，包括整形、字符型、数组、对象等。但是，Value 对数据库而言是透明不可见的，不能对 Value 进行索引和存储，只能通过 Key 进行查询。

键值数据库可以进一步划分为内存键值数据库和持久化键值数据库。

• 内存键值数据库把数据保存在内存，如 Memcached、Redis
• 持久化键值数据库把数据保存在磁盘，如 BerkeleyDb、Riak

键值数据库有自身的局限，条件查询就是键值数据库的弱项。因此，在使用键值数据库时，应该尽量避免多表关联查询，可以采用双向冗余存储关系来替代表关联，把操作分解为单表操作。

项目	描述
相关产品	Redis、Riak、SimpleDB、Chordless、Memcached
数据模型	键/值对 键是一个字符串对象 值可以是任意类型的数据，比如整型、字符型、数组、列表、集合等
典型应用	拥有简单数据模型的应用，涉及频繁读写 内容缓存，比如会话、配置文件、参数、购物车等
优点	扩展性好，灵活性好，大量写操作时性能高
缺点	无法存储结构化信息，条件查询效率较低
不适用情景	不是通过键而是通过值来查：键值数据库没有通过值查询的途径 需要存储数据之间的关系：在键值数据库中，不能通过两个或两个以上的键来关联数据 需要事务的支持：在一些键值数据库中，产生故障时，不可以回滚
使用者	百度云数据库（Redis）、GitHub（Riak）、BestBuy（Riak）、Twitter（Redis和 Memcached）、StackOverFlow（Redis）、Instagram （Redis）、Youtube （Memcached）、Wikipedia（Memcached）

目前使用最多的是 Redis，被称为“强化版的Memcached”，被广泛应用在数据缓存方面

• 支持持久化
• 数据恢复
• 更多数据类型

列族数据库

列族数据库一般采用列族数据模型，数据库由多个行组成，每行数据包含多个列族，不同的行可以具有不同数量的列族，属于同一列族的数据会被存放在一起。

项目	描述
相关产品	BigTable、HBase、Cassandra、Hypertable、GreenPlum等
数据模型	列族
典型应用	分布式数据存储与管理 数据在地理上分布于多个数据中心的应用程序 可以容忍副本中存在短期不一致情况的应用程序 拥有动态字段的应用程序 拥有潜在大量数据的应用程序，大到几百TB的数据
优点	查找速度快，可扩展性强，容易进行分布式扩展，复杂性低
缺点	功能较少，大都不支持强事务一致性
不适用情景	需要ACID事务支持的情形，Cassandra等产品就不适用
使用者	Ebay（Cassandra）、Instagram（Cassandra）、NASA（Cassandra）、 Twitter（Cassandra and HBase）、Facebook（Cassandra）、Yahoo! （HBase）

文档数据库

在文档数据库中，文档是数据库的最小单位。文档是一个数据记录，这个记录能够对包含的数据类型和内容进行“自我描述。文档数据库旨在将半结构化数据存储为文档，通常用XML、 JSON 等文档格式来封装和编码数据。

一个文档可以包含非常复杂的数据结构，如嵌套对象，且每个文档可以有完全不同的数据结构，每一条记录包含了所有的有关信息而没有任何外部的引用，这条记录就是“自包含”的，这使得记录很容易完成数据迁移。

文档数据库既可以根据键（Key）来构建索引，也可以根据文档内容构建索引。尤其是基于文档内容的索引和查询这种能力，是文档数据库不同于键值数据库的地方。

项目	描述
相关产品	MongoDB、CouchDB、Terrastore、MarkLogic、RavenDB
数据模型	键/值 值（value）是版本化的文档
典型应用	存储、索引并管理面向文档的数据或者类似的半结构化数据 比如，用于后台具有大量读写操作的网站、使用JSON数据结构的应用、 使用嵌套结构等非规范化数据的应用程序
优点	性能好（高并发），复杂性低，数据结构灵活 提供嵌入式文档功能，将经常查询的数据存储在同一个文档中 既可以根据键来构建索引，也可以根据内容构建索引
缺点	缺乏统一的查询语法
不适用情景	在不同的文档上添加事务。文档数据库并不支持文档间的事务，如果对 这方面有需求则不应该选用这个解决方案
使用者	百度云数据库（MongoDB）、SAP （MongoDB）、Codecademy （MongoDB）、Foursquare （MongoDB）、NBC News （RavenDB）

图形数据库

图数据库使用图作为数据模型来存储数据，完全不同于键值、文档和列族数据模型，可以高效地存储不同顶点之间的关系。图数据库专门用来处理具有高度相互关联关系的数据，可以高效地处理实体之间的关系，比较适合于社交网络、模式识别、依赖分析、推荐系统以及路径寻找等问题。

但是，除了在处理图和关系这些应用领域具有很好的性能之外，在别的领域，图数据库的性能不如其他 NoSQL 数据库。

项目	描述
相关产品	Neo4J、Infinite Graph、GraphDB
数据模型	图结构
典型应用	应用于大量复杂、互连接、低结构化的图结构场合，如社交网络、推荐系统等
优点	灵活性高，支持复杂的图形算法，可用于构建复杂的关系图谱
缺点	复杂性高，只能支持一定的数据规模
使用者	Adobe（Neo4J）、Cisco（Neo4J）、T-Mobile（Neo4J）

不同类型数据库比较

MySQL

• 功能较稳定强大，满足多样需求

MongoDB

• 数据模型较灵活，支持较多功能

HBase

• 具有很好的扩展性，依赖 Hadoop 生态环境

Redis

• 模型较为简单，可提供随机数据存储，数据库伸缩性较好

NoSQL的三大基石

NoSQL的三大基石包括 CAP、BASE 和最终一致性。

CAP

CAP理论指的是：

• C（Consistency）：一致性，是指任何一个读操作总是能够读到之前完成的写操作的结果，也就是在分布式环境中，多点的数据是一致的，或者说，所有节点在同一时间具有相同的数据
• A:（Availability）：可用性，是指快速获取数据，可以在确定的时间内返回操作结果，保证每个请求不管成功或者失败都有响应
• P（Tolerance of Network Partition）：分区容忍性，是指当出现网络分区的情况时（即系统中的一部分节点无法和其他节点进行通信），分离的系统也能够正常运行， 也就是说，系统中任意信息的丢失或失败不会影响系统的继续运作

CAP理论告诉我们，一个分布式系统不可能同时满足一致性、可用性和分区容忍性这三个需求，最多只能同时满足其中两个。

处理CAP的问题时的选择：

• CA：强调一致性（C）和可用性（A），放弃分区容忍性（P），最简单的做法是把所有与事务相关的内容都放到同一台机器上。很显然，这种做法会严重影响系统的可扩展性
• CP：强调一致性（C）和分区容忍性（P），放弃可用性（A），当出现网络分区的情况时，受影响的服务需要等待数据一致，因此在等待期间就无法对外提供服务
• AP：强调可用性（A）和分区容忍性（P），放弃一致性（C），允许系统返回不一致的数据

BASE

数据库事务的 ACID 特性

• A（Atomicity）：原子性，是指事务必须是原子工作单元，对于其数据修改，要么全都执行，要么全都不执行
• C（Consistency）：一致性，是指事务在完成时，必须使所有的数据都保持一致状态
• I（Isolation）：隔离性，是指由并发事务所做的修改必须与任何其它并发事务所做的修改隔离
• D（Durability）：持久性，是指事务完成之后，它对于系统的影响是永久性的，该修改即使出现致命的系统故 障也将一直保持

关系数据库系统设计了复杂的事务管理机制来保证事务在执行过程中严格满足 ACID 的要求，较好地满足了银行等领域对数据一致性的要求，因此得到了广泛的商业应用。

但是，NoSQL 数据库通常应用与 Web 2.0网站等应用场景中，对数据一致性要求并不是很高，而是强调系统的高可用性。因此为了获得高可用性，可以考虑适当牺牲一致性或分区容忍性。BASE的基本思想就是在这个基础上发展起来的，是完全不同于 ACID 模型的，BASE 牺牲了高一致性，从而获得了可用性或可靠性。

BASE 的基本含义是 基本可用、软状态 和 最终一致性。

• 基本可用（Basically Available）：是指一个分布式系统的一部分发生问题变得不可用时，其他部分仍然可以正常使用，也就是允许分区失败的情形出现
• 软状态（Soft-state）：是与“硬状态（hardstate）”相对应的一种提法。数据库保存的数据是“硬状态”时，可以保证数据一致性，即保证数据一直是正确的。“软状态”是指状态可以有一段时间不同步，具有一定的滞后性
• 最终一致性（Eventual consistency）：一致性的类型包括强一致性和弱一致性，二者的主要区别在于高并发的数据访问操作下，后续操作是否能够获取最新的数据。
  • 对于强一致性而言，当执行完一次更新操作后，后续的其他读操作就可以保证读到更新后的最新数据。关系数据库通常实现强一致性
  • 反之，如果不能保证后续访问读到的都是更新后的最新数据，那么就是弱一致性。而最终一致性只不过是弱一致性的一种特例，允许后续的访问操作可以暂时读不到更新后的数据，但是经过一段时间之后，必须最终读到更新后的数据

最终一致性

最终一致性根据更新数据后各进程访问到数据的时间和方式的不同，又可以区分为：

• 因果一致性 (Causal consistency）：如果进程A通知进 程B它已更新了一个数据项，那么进程B的后续访问将获 得A写入的最新值。而与进程A无因果关系的进程C的访 问，仍然遵守一般的最终一致性规则
  

• “读己之所写”一致性 (Read your writes）：可以视为 因果一致性的一个特例。当进程A自己执行一个更新操 作之后，它自己总是可以访问到更新过的值，绝不会看 到旧值
  

• 会话一致性 (Session consistency）：系统能保证在同 一个有效的会话中实现 “读己之所写” 的一致性，也 就是说，执行更新操作之后，客户端能够在同一个会话 中始终读取到该数据项的最新值
  

• 单调读一致性：如果进程已经看到过数据对象的某个值， 那么任何后续访问都不会返回在那个值之前的值

• 单调写一致性：系统保证来自同一个进程的写操作顺序 执行，对于多副本系统来说，保证写顺序的一致性（串 行化），是很重要的

在分布式数据系统中，将数据冗余的份数记为N，更新数据时需要保证写完成的节点数记为W，读取数据时需要读取的节点数记为R。

• 如果W+R>N，写的节点和读的节点重叠，则是强一致性。例如对于典型的一主一备同步复制的关系型数据库， N=2,W=2,R=1，则不管读的是主库还是备库的数据，都 是一致的。一般设定是R＋W = N+1，这是保证强一致性的最小设定
• 如果W+R<=N，则是弱一致性。例如对于一主一备异步 复制的关系型数据库，N=2,W=1,R=1，则如果读的是备 库，就可能无法读取主库已经更新过的数据，所以是弱一致性。

对于分布式系统，为了保证高可用性，一般设置N>=3。不同的N,W,R 组合，是在可用性和一致性之间取一个平衡，以适应不同的应用场景。

如果N=W,R=1，任何一个写节点失效，都会导致写失败，因此可用性会降低，但是由于数据分布的N个节点是同步写入的，因此可以保证强一致性

HBase是借助其底层的HDFS来实现其数据冗余备份的。HDFS采用的就是强一致性保证。在数据没有完全同步到N个节点前，写操作不会返 回成功。也就是说它的 W＝N，而读操作只需要读到一个值即可，也就是说它的 R＝1

而 Cassandra 等系统，通常都允许用户按需要设置N，R，W三个值， 即可设置成W＋R<= N，也就是说允许用户在强一致性和最终一致性之 间自由选择。而在用户选择了最终一致性，或者是W<N的强一致性时，则总会出现一段“各个节点数据不同步导致系统处理不一致的时间”。为了提供最终一致性的支持，这些系统会提供一些工具来使数据更新被最终同步到所有相关节点

NewSQL数据库

尽管 NoSQL 数据库较好地满足了 Web 2.0应用的需求，但是 NoSQL 不具备高度结构化查询等特性，复杂查询的效率不如关系数据库，而且不支持事务ACID。

在这样的背景下，NewSQL 数据库开始升温。NewSQL 是对各种新的可扩展/高性能数据库的简称，这类数据库不仅具有NoSQL对海量数据的存储管理能力， 还保持了传统数据库支持ACID和SQL等特性。

在大数据时代，数据库架构开始向着多元化方向发展，并形成了传统关系数据库（OldSQL）、NoSQL 和 NewSQL 数据库三个阵营，三者各有自己的应用场景和发展空间。在未来的一段时间内，三个阵营共存共荣的局面还将持续。