数据库系统实现变革在线视频

然后刚才讲到了第二个变革对吗

就是从SQL到NewSQL

它这个主要就是说是为了这种

更高的这种性能

性能上面的一些考虑

刚才我们提到的就是说

传统的（英文）

它就是它这个（英文）

实际上就是说我数据

我最终是要存在我的硬盘上面

我的硬盘上面

然后完了之后我的硬盘

然后有存储器

然后当然存储器完了之后

可能上面还会有很多

比如说CPU的L1 L2 L3 L4的

这种（英文）然后等等

这个中的里的这个数据

被CPU来处理的时候

它可能从这basic

然后一路到这个

CPU的这个（英文）里头

就是集成器里头

它中间经过了很长很长的一段路

那么这个有一个图 这有一个图

我不知道后边的同学能不能看清楚

就是说这是2007年

一个研究组他们做的

就是说他们是拿一个（英文）

上面的一个叫neworder

这样的一个（英文）

就是neworder大家能想到对吧

就是我去新加一个订单这样的操作

但是它可能涉及到好几个

（英文）内部的操作

大家会看到它就是说

它这个统计出来的

一共是将近两个million

这样的一些CPU的指令

然后你会看到它这样的一个分布

你会看到这是真正的

做那些有用的工作

就是你改了一个记录

或者去做那些逻辑的一些运算

然后其它的90%以上的这个时间

大家可以看看它在干什么

就是说这种（英文）

这是数据库里头

一个很重要的这样的一个

就是说去提高性能的这样一个机制

对吧 就是把这个（英文）

和这个（英文）

能够做一些同步 做一些（英文）

然后这有一些launching

这有一些locking

这数据库里头的并发控制方面的

很重要的两个技术

然后后面logging 就是做日志

然后后面这种

其它的这样的一些（英文）等等

所以你看到就是基本上

在这个传统的数据库里头

因为它用的那一套机制

或者是说它依赖于

这个传统的这种存储体系

发展起来的这些

很多这种一些技术

比如说包括这些（英文）

这样的一些技术

在整个的这个处理过程中间

它占了大量的CPU（英文）

而且这些东西实际上就是

如果我是个用户我可能不关心这个

我就关心你把我的事做了就完了对吧

所以他真正的关心的这个事情

就是这个那么也就是说90%以上的

CPU的（英文）

实际上是被浪费掉了 OK

这是一个非常非常震撼的

这样的一个数

就是你可以 刚开始没有想到

如果大家感兴趣的话

你可以去拿一个（英文）这样一个

比如说（英文）也好

或者是那个（英文）

你可以去看一下

就是说（英文）下去

你看它这个调用关系

看那个调用关系

它内部有很多很多各种各样的函数

我们原来做过一回

就是大概一二十层的

这样的一个调用关系

你就看见真正最后做那个

这就叫（英文）

其实做这种实际的

这种工作的这个那几个函数

就那么一点点

大量的时间都花在这个

数据库内部各种各样的

就是人们过去几十年发展出来

这样一些技术这个上面

但是这个技术

它最终的目的就是保证那个很好的

或者是这个理想的这种ACID（英文）

你不能说没有用

但是很多情况下就是说是

因为这个硬件环境这样的一些限制

所以认识到这点

那么就是说我们怎么能够去

就是我们刚才也看到对吧

就是说实际上在传统的这种

基于（英文）的

这样一些（英文）上面

你有很多事情甚至做不了的

就是有很多大量的

比如说这种（英文）

你如果想把它实时的（英文）下来

然后在上面做统计

在这个传统的（英文）上面

实际上你能够做到几百个QPS

几千个QPS撑死了

但是实际上就是说在这种

互联网这种情况下

几万个 十几万个这种QPS

甚至也会更多

这个是个非常常见的

这样的一个（英文）

那么在这种情况下

你怎么能够做到这一点呢

就是实际上我们从大概是2007年

2008年 2009年那几年

也出了很多这方面的一些工作

就是在想这个事

但是就是说那几年

实际上就是说大家可以看到

CPU的这个核数越来越多对吧

我们现在可以看到

一个CPU一二十个core

非常非常普遍的

然后这个memory

就是说这种内存 内存以前可能

我记得我在学校的时候

配一个G的内存好像就不得了了

那时候可能很多机器

就是几十个兆对吧

你现在机器可能稍微好一点的

你配个几十个G的

然后好一点的这种服务器

几百个G 甚至上T的这种内存

实际上是不是说买不起了

就是大家一般稍微花点钱

还都能买得起 买得起完了之后

那么比如说你到了几百个（英文）

或者是多少个T

这样的一个级别的时候

（英文）的这样的一个级别的时候

你会发现我可以完全的

把我的这个数据库

刚才我前面有个表

基本上我就可以

一台机器装不下我多用几台机器

我就可以把我的数据

都装到memory里头

那么这种情况下

就是说你至少从这个层面

这个（英文）这块东西

我先不考虑其它的一些这种（英文）

就是（英文）这方面的一些东西

那么这块实际上就可以省掉一大块

这个三分之一了

就是仅仅是这样的一个改动

那么就是我可以把这一大块

不必要的开销把它给干掉对吧

那么就是说如果把这个开销干掉

那么（英文）我CPU的SQL

能够做更多的这种有用的事情

那么我能够去达到更高的（英文）

我能够去做到更低的（英文）

然后我可以把这个（英文）

能不能够做到跟那个（英文）

这样的（英文）能够做到

不是说完全跟它一样吧

因为你要做到（英文）那种

几乎是（英文）

这个可能还是有一些难度的

因为在那个（英文）

毕竟你还是做（英文）

做（英文）的时候

你要想做到（英文）这种（英文）

实际上是比较难的

那么我能不能做到这种ACID

这个非常好的这样一个（英文）对吧

然后还希望是说

这种（英文）这种（英文）

能够（英文）

然后能够去支持这些SQL

这样的一些东西

所以就是说那么实际上本质来讲

就是说我要去保证这个传统的

这样的一些（英文）的基础上

然后还去在它（英文）

和这个（英文）这种性能方面

能够达到NoSQL它所

我们所在那个环境底下

所看到的这样的一些东西

这底下有一个表

这个可能大家也许在某些地方见过

就是讲它这个CPU

就是整个硬件的这样一套存储

包括网络传输的这样一些带宽

这样的一个延迟的这样一些数

基本上就是在内部的这样的

可能在纳秒级这样

然后到外面就是说

可能几个数量级的这种差别

这个图大概能够就把这个

把这个差别把它显示出来

所以基本上

我们就是怎么去利用这个

内部的这种硬件环境

在访问这个数据的

这种性能上的一些差别

然后去把这个硬件的这种架构

能够去把它设计好

然后在这个相应的基础上

再去设计相应的这种软件系统

实际上这个中间有一些

比较有代表性的这样的一个工作

就是这个是那个叫H-Store

它后来有一个

它刚开始开源的这样一个项目

应该是在2009年的时候

他们把它做成了一个

商业的一个公司叫（英文）

它仍然是有一个开源的版本

是个（英文）

大家感兴趣的话可以去看一下

他实际上就是说基本的想法

就是说他把它这个数据

首先把它都hold到memory里头

我先看这个吧 先看这边

它是一个（英文）这样一个结构

就是说我是一组机器 一组机器

但最多的我们测过的是到几十台

几十台 但是一般情况下

可以根据自己的

这个数据量这种情况去灵活的配置

然后把这一台机器

然后根据这个CPU CPU的情况

我可以把它这个δ

实际上就是一个表吧

一个表我们去把它分成

就是（英文）

先把它给切分开

然后一个（英文）大概就是

有一个专门的

一个Core来对付它

然后这样的就是说

比如说一个机器有16个Core

或者24个Core

或者是更多的Core的时候

我可以根据这个机器的

这样的一个硬件的Core

物理核数的情况

我去把它去做这样的一些划分

划分完了之后

这个实际上就是说每一个

一个大的表 一个大的表

它实际上是在这个

这个Cluster里头

所有的这些机器上

机器上去把它给（英文）

就是比如说我有十台机器

我一个表

比如说原来有100个 100个（英文）

那就是一个亿的这种记录

我们实际上每台机器

可以存十个（英文）

就是一千万记录对吧

然后一个机器

比如说我用10个Core（英文）

那么实际上一个（英文）

所以要管理的数据

基本上就是一个（英文）

这样的一个级别

那么实际上在这样的一个结构下

实际上就是一个典型的一个MPP

就是一个（英文）这样的一个架构

刚才提到的比如说就是在（英文）

那个他们拿来和这个（英文）

做这个性能对比的时候

用到的这也是这样一个架构的

一个MPP的（09：14）

但是它是传统的

就是基于（英文）的

它的很多的这种

就是我刚才提到的那些

（英文）的地方都还在

但是这个情况

就是它做的比较更接近一些

就是我把数据（09：26）

大家可能会问

那你将来（英文）怎么样

这可能是另外一个问题

它是有解决方案的

我们今天不一定有时间来讨论它

但是我恩先把基本的这个想法

就是它把这个数据

我把（英文）

然后每一个Core去（英文）

这样的话就是说

我打个最简单的比方

比如说我做一个（英文）

或者一个（英文）

我实际上原来比如说在一台机器上

我要去（英文）100个（英文）

针对一个CPU来干

我现在在10台机器上

有100个Core同时的完成这个

大家可以想一下基本上就是说

我可能完成这个操作

这个时间就是原来1%

所以基本上就是说

为这种分析型的这样一个（英文）

实际上也提供了

很好的这样一个基础

另外一个方面就是说它的这个

执行的这样的一个模式

它也会发生一些变化

就是说我还是考虑一个

最简单的情况

比如说我用了一个（英文）

我只会（英文）其中的一个（英文）

那么实际上在任何一个（英文）上面

我就没有必要我去做任何的这个

就是那种复杂的这种（英文）

为什么呢

因为（英文）大家可以看到

刚才那些（英文）

然后那些（英文）这些操作

实际上它也是

非常非常耗CPU资源的

那我最简单的一个模型就是说

我把你这些所有的这些（英文）

我就排队

我就一个个做 一个个做

实际上因为在这种情况下

它因为它要处理这种数据量

然后包括这个（英文）

它这个时间非常非常短

它可能能够完成

比如说我一个操作大概在几个毫秒

甚至更短的时间就把它做掉的话

我如果要去做那些复杂的（英文）

我那些操作的时间可能已经足够

我把这个操作做好几遍了

所以它基本上就是

采取这样的一个方式

我让每一个Core去串行的

去做这样的它的这些（英文）

然后把所有的（英文）

都（11：17）里头

这样做到的这个结果

就是大家可以看得到

就是说这个数字可能有点小

但是基本上上面就是已经

这是80万 80万

这是12个read

基本上可以看到它的这种

它这个（英文）

它是基于这个雅虎的这个（英文）

这样的一个结果

但是这是用的是那个（英文）

这个大家在网上可以查得到的

它这种（英文）

这样有一个（英文）这样一些比例

然后一个是50%对50%

一个是95%对5%

所以你一看基本上就是说

它的这种（英文）

这是两个read 四个read

八个read

十二个（英文）这样的

你可以看到的基本上就是这种

线性的这种在增长

就是它的说他的这之种（英文）

这个也是

基本上是这样一个状况对吧

这是它的（英文）

这个（英文）它的这个时间

是1 2一直到8 这是毫秒为单位

所以基本上就是说它的这种操作

这个操作它实际上还是比较复杂的

并不是那么简单的这种

一个（英文）的这种查询

或者是一些（英文）这样的操作

它能够基本上在几个毫秒

就是很少很少的几个毫秒时间

就把这个做掉

但是这个地方可能

它扩展到就是说这个（英文）

它加到一定程度的时候

它系统内部的这样一些影响

它有一个跳变

但是在这个范围里头

它实际上是一个

非常好的这样的一个

基本上你看它没有什么大的变化

OK 然后它的这个TV99这样的

也是一个非常好的

这样的一个保持的这样一个特征

基本上就是你可以（英文）

我一个（英文）下去

我大概多长时间能回来

有一个很好的一个比较稳定的预期

你在传这个（英文）上面

它那个磁盘在这转对吧

有的快一点 有的慢一点

有时候它不知转哪去了

它那个（英文）

它的这个跳动的这个区间会比较大

所以这个就是说这种（英文）

它采取的这样的一些新的一些技术

能够就是说主要是应用这种

最新的这种硬件的这样一些成果

比如说包括这种大的内存

然后更多的CPUCore等等

这样的一些方案能够去把这个

就是从这个（英文）

然后到它这个（英文）

然后到它的这种（英文）

这几个方面的东西

都能够很好的保持

而且还能保持就是传统（英文）

它的已经有的这些优势

比如说对于Core的这种（英文）

对于ACID这样的（英文）

对于（英文）这样的（英文）

这个是应该来说

非常非常有前途的

这样的一个技术的一个动向

然后这个数不知道为什么

算了 我跳过吧

这个是另外一个

测试的这样一个结果

虽然就是它是在另外一个平台上面

这是我们自己做的这样一个结果

当时是也是用在几个不同的

用在其中也是一个（英文）

这样的一个东西

所以看到基本上就是说

它的这种（英文）

也是一个很好很好的

这样的一个曲线

这是在就是说我们怎么去用

这样的一些

新的这样一些硬件环境

但是谷歌做了一个东西叫（英文）

它这个实际上应该是在

那个（英文）之后

（英文）当时他们做完了之后

就是说反思一下

可能最大的一个失误

可能就是当时把这个（英文）

这种支持把它给没有做到系统里头去

后来他们在做这一版

这个（英文）的时候

就非常注重这一点

就是说把这个（英文）

做到这个里头

但是它仍然是基于这种

就是传统的这种（英文）

就是说有（英文）

然后在多个数据中心

然后能够做到

实际你可以看到的

它就用这种（英文）

包括它的这种（英文）

仍然是能够做的非常非常好的

这样的一个状况

具体细节可能大家感兴趣的话

可以去看一下

这个（英文）里头一些东西

它也用到了很多新的

这样的一些技术

比如说包括这些GBS

那么就做这种时间的同步然后等等

所以就是说

跟这个（英文）这个（英文）

那么刚才我们看到就是说

你实际上在

如果我把这个（英文）

把这个简化的情况下面

就是说如果一个（英文）

一个（英文）都

它那些（英文）

都只（英文）它一个（英文）

那么这种情况下实际上是可以

几乎就是你可以做到（英文）对吧

但是如果你还是要去做这种2PC

比如说你要去做这种（英文）

这种情况下咱们怎么能够去克服

现有的这样的一个

硬件的这样的一些限制

或者是现有的这样的一个（英文）

这方面的一些限制 能够去突破

就是真正的大规模这种情况下

能够做到（英文）这种（英文）

然后对于这种分布式的

因为分布式的不稳定点

就是多个（英文）之间的

它这种互相的这种（英文）

它这种情况下你怎么能够去

仍然是保持它的这种

比如说刚才看到的这种

非常非常高的这种（英文）

然后非常平稳的这种（英文）等等

这方面的特征

这个实际上是有大量的事情

还可以需要去做的

实际上就是MPPSQL

它这个东西就是包括传统的

基于（英文）的这样的一个

我刚才提到的就是到几百个机器

可能就基本上就到头了

你再想加实际上是对系统的

这种（英文）

或者其它方面的这种处理能力的提高

是没有太多的这种帮助的

那么在这一方面

如果我们说能够基于这些新的

这样的一些硬件

在这种新的这种架构的方面

能够去把这两个问题

就是这种（英文）这种（英文）

或者这种（英文）

能把它解决好的话这个将会

有非常非常多的机会