从sql到nosql在线视频

OK 所以我们基本上看一下

就是前面的

我们从回顾了一下这个历史

然后我们看到的是这样的一些

现在的这样的一些

硬件的这种平台的一些变化

我们看到的是这种数据处理

这个要求上的一些变化

然后我们把它总结一下呢

就是基本上就是说

我们看到的是四种不同的

我们叫四个不同的这种变革

第一个就是从这个数据模型方面

数据模型从这种关系型的

这样一个数据

然后再到这种非结构化的

这样的数据

这样就是说从这种SQL

然后转向NoSQL

这个NoSQL这样的一些东西会

实际上在这个整个系统里头

变成了一个不可忽视的

这样的一个因素

实际上在很多（情况）下

起着非常关键的作用

然后另外一个

从这个系统实现上

系统实现上

大家如果就是说对于数据库

就是传统的这个RDMS

这样的一套东西

如果在学校学过的话

或者是自己去用过的话

你就会知道它实际上

它的这个里头的很多做法

一会儿底下我就会讲到

比如说它的这种（英文）

就是它的这种（英文）

然后包括它这种（英文）

然后等等

类似于很多这样的

就是数据库

传统数据库的人引以为自豪的

引以为豪的这样一些技术

实际在新的这种硬件环境下面

变得变成了一些障碍性的

这样的一些东西

这样的话就是说

做数据库的人也在考虑

就是怎么能够去结合

现有的这样一些硬件环境

然后能够有一些新的

更精简的更快的

这样的一些数据库系统

这样的一些实现出来

这就是变成这样的一些NewSQL

我们叫NewSQL

这是第二个变化

然后第三个变化实际上就是说

以前的这个OLAP和这个OLTP

当然如果对于这种企业的

这种计算环境有了解的话

你就会发现

它实际上是一个

非常非常（一般）的

这样的一个（模式）

就是什么呢

就是我的这些（英文）这些数据

是在一个比如说一个oracle

或者是一个（英文）

或者一个（英文）

这样的一个数据库里头

然后后台会有一些

周期性的这样的一些

ETL的这样的一些工具

然后把这个（英文）

就是交易的这样一些数据

然后把它给（英文）出来

（英文）出来

放到一个数据仓库里头去

就是一个OLAP的

这样的一个（英文）里头去

所以这两套系统当时的

为什么这么做的一个原因

就在于说这个OLTP这样一个系统

它受不了这个干扰

你如果说在这个上面

去跑这个OLAP的这样的任务的话

那么基本上它会把所有的资源

都吃光

你这个系统的（英文）

就基本上就没有了

也就是说你往里头

想查一条记录

或者是做一点什么查询

基本上就（英文）

所以当时把这个OLTP和这个OLAP

这样的一些东西它分开

它是有它的原因的

就是说它主要是基于

我说不要让这个OLAP的

这样的一些（02：55英文）

去影响这些（英文）

但是这个也是有历史原因

形成了这样的一个方案

就是实际上就是什么原因呢

就是说这些OLAP的

这样的一些结果

一般说是给企业的

这些管理者用到的对吧

在企业里头它实际上

它很多这种

基于这样统计的结果

做了一些决策

然后它反映到这个生产

这个环境底下去

它中间这个过程会比较长

什么意思呢

就是说你比如说你要

你要看 根据过去的

这个销售的这样的一些记录

然后去决定

比如说我的这个产品研发的

这样的一些方向

或者说我的市场这个推广

或者是其他方面的一些

活动的这样的方向的时候

这个决策到真正这些

实际的研发流程

或者是这个投放的

这样的一些活动的开展

它中间至少会有

是天或者是星期或者是月这样的

这样的一个（延迟）

然后这些效果的

最后能够反映到这个

比如说销量的这样一些变化

或者是整个产品的这个

形态的这样一些变化的时候

它可能是一个更长的

这样的一个周期

那么这个时效性可能就是说

从这个OLAP这样的一些

分析的这样的一些结果

应用到这个生产的

交易的这样一个流程这个中间

它的这个时效性

可能要求并不是那么强

所以它把它分开

分开去弄

那样也能很好的避免

就是两种不同的（英文）互相干扰

但是实际上大家会在

现在的这些互联网的

这些应用里头看到

实际上就是说基于统计的

这样的一些分析结果

比如说底下会讲到一个例子

就是说有一些 你个性化的

就是比如说

现在大家在这个电商网站上

去买东西

它出来的东西

如果做的比较好的话

它应该是说

它能够出一些

你可能会感兴趣的

根据你比如你以往看过的一些

类别的一些东西

或者是一些这种价位

方面的一些东西

然后等等

去根据你个人的一些口味

去做到出来的东西

能够做到一些有个性化的调整

我们这叫个性化的这样一些推荐

这个东西呢这个技术呢

实际上是最早是在

这种新闻的这种推荐里头出来的

可能现在咱们国内

有几个比较流行的

比如头条或者是 还有一个是

就是这样的一些新闻网站的话

它会用到这样的一些

个性化的一些

推进的一些技术

这个技术它这个时效

时效性的要求

就是说它是根据大家过往的

比如说甚至是上一秒

或者是上几分钟

这样的一些行为

然后它把这些行为的

这样的一些分析的结果

马上就运用到

它的这个生产系统去

所以你看这个延迟

它非常非常短

就是大概是一秒

这样的一个单位

这个传统的企业里头

可能是多少个天或者是多少月

因为这样的一个时间的变化

如果说我们还把这些

（英文）和这个OLAP

就是分析性的这样的

包括后来刚才我提到的

这种机器学习的这样的东西

如果我们把它分开的话

实际上你要想达到这种

个性化的这样一些效果

或者是能够很好的优化

这些线上的一些体验

实际上是很难很难的

所以就是说因为这种新的

这种运用需求

然后导致说

我们要把以前在不同系统

完成的这样的一些处理

然后融合到同一个系统里头去

这个是第三个方面的一些变化

然后最后一点

就是说可能比较大的一个变化

就是这种交付方式

交付方式以前可能就是说

大家习惯于说

我去买一堆机器

买一堆机器

然后我把我的系统

建在我的机房里

然后我能够控制所有的事情

但实际上现在就是说

以前如果你是买一个

装一个（06：21英文）

或者其他的一个数据库

反正就是一两台机器

找一个人 哪怕是兼职

可能也能够维护的比较好

对吧

但是现在要看

我们现在新有的

比如刚才我在前面那个检验室

那个（英文）列到了

很多这种大的系统

它涉及到的

一般情况下你装十几台二十台

甚至上百台机器

这都是非常非常普通的

这样的一个配置

大的机构可能上千台上万台

这样的一些机器在这儿run

你如果说这些东西

要人去把它维护好

这绝对不是一个小的（英文）

很多公司需要一些专业的

这样的一些团队

而且把这些东西让它去

也就是说做各方面的这种优化

比如说性能方面配置方面等等

各方面的一些优化

这绝对不是一个

就是单个的人能够完成的

对于很多这种企业来说

它的这些方面的这些开销

是一个不可以忽视的

这样的一个因素

所以就是说那么

现在一些新的这种方式

那么就是说

我们通过这种云的

服务的这种方式

你把数据传上去

把数据传上去

然后你在上面各种各样的

一些分析的这样的

包括应用系统这样的等等

串起来

这样的服务都在云端

能够自动的

就是或者说以最优的这种方式

帮大家把这个做了

你要关心的就是你的数据

怎么能够收集回来

然后你的这些模型该怎么建立

你的这些后台的这些服务

该怎么去搭建

大家关注的可能是这些事情

然后把底层的这些硬件的

然后包括这些软件平台的

这样一些复杂性都给它屏蔽掉

这个实际上就是说

现在看到的一个

比较大的一个变化

所以因为有了这方面的一些变化

我们可以看看从SQL到NoSQL

那么实际上就是说到NoSQL

NoSQL的 它这个驱动力就是说

说了更好的去扩充系统

就是说我从原来的

比如说一两台机器

然后我机器不够了

我就把这个机器不断的升级

加入更多的CPU

加入更多的内存

去买更好的内盘

然后扩展到

因为这个SQLUP

实际上它这种SQLUP的

这种方式呢

它实际上是有一定的局限的

你可能扩展到一定的程度之后

你就很难再扩充上去了

那么你的业务量

你的workload在不停的

不断的提升

那么到一定的阶段

你可能就再也撑不住了

所以就是说为了这种可扩展性

实际上大家就是

采取的是互联网公司

常见的一些做法

就是叫SQLout

那么SQLout大家可能看到

如果对于这个关系模型

有一些了解了

你就发现它是一个约束性

非常强的

很多操作你想把它能够

在一个单机上能够做的很好

但是你要是把它给

放到一个集群上去做的话

可能操作就做起来

就非常非常麻烦

甚至是做不好的

那这种情况下

也就是说我们怎么能够去把这个

这个SQL这方面的一些限制

把它给去掉了

就是很多这种NoSQL

这样的一些技术

就是说要把它的这种

从这种SQLup然后转向SQLout

这样的一个东西

从这个扩展性方面

做一些这样的一些转变

然后另外一个

就是我们对

刚才提到的这种可用性方面

我们能够做更准确的

这样的一些控制

这是 这是这个

主要的这个驱动力

然后从这个数据结构上来讲的话

那么它就是说

它希望是一个比较简单的

这样一个数据结构

就是从这个平台

系统平台本身的话

我们希望这个数据结构

越来越简单 越简单越好

不像那个关系

关系当然是很简单

而且关系大家喜欢它的

一个很重要的原因

就是说它有比较好的

这样一个数学基础

那么现在来看

更多的比如说像我在这儿

列出来的几个数据结构

比如像这个Key-value

这种键值对 对吗

然后比如这种我们叫宽表

就是实际上把所有的东西

都堆在一块

然后包括这些图

然后包括这些文档

实际上有一点简单粗暴

我觉得先不管三七二十一

先把这些东西堆起来

采用一种

这种适用性的这样的方式

它从数学上讲

它没有什么太多的这种数学基础

那除了那个Gragh

那个东西之外 对吧

但是它是一个比较特殊的

但是它整个它就是说

你要去管理这样的一些数据

我就先把它弄进去

我尽量这个系统

能够把它给存起来

能够去处理它

然后具体很多这种

应用的这种逻辑

它可能在上面

它就没有像SQL那样一个

很好的这样一个

编程的一个抽象

我什么东西都可以SQL去处理

那这种情况下你可能需要

其他的一些定制化的

这样的一些程序

比如说这种（英文）

这样的一些程序我去处理它

然后这些程序处理逻辑

我就根据这个

数据的这样的一些特点

然后在这上面去定制化

然后在这上面

这样的话实际它就把这个

就是你传统的

在这个（英文）上面

比如说你去做（英文）等等

这样一些操作

然后可以通过其他的一些

应用逻辑上的这样的一些调整

或者是这个平台的

这样一些简化

能够让它能够

在这个扩展性方面

能够做得更好

当然这个NoSQL

这个东西它出来之后

最初它还是想要去跟

因为SQL的各种各样的一些局限

然后 但是实际上后来发现

这个SQL是大家

实际是绕不过去的

最主要的原因就是SQL

已经是有一个

非常非常强烈的

这样一个用户基础

就是实际大家对这个东西

都非常熟悉

实际上后来大家如果看的话

就是在很多的

这样的一些NoSQL的

这样的一些基础上

大家也在不断的

往里头加上一些SQL的

这样的一些就是（英文）

就是实际上现在的

比如说（英文）

然后包括（英文）上的

这些（英文）

然后包括这个（英文）里头的

它叫（英文）

然后其他的等等等等

基本上就是说我去上面加一个

这个SQL（英文）

就变成了一个标准的

这样的一个配置

没有这个可能这个系统

被别人用的这种可能性

就会大大的降低

所以它就是

这个NoSQL慢慢的

它的这种变化

就是变成了（英文）

因为这个现在的

现在的这个NoSQL的

这个系统上的这种SQL的支持

相比我们做了几十年的

这个（12：05）上的这个支持来说

实在是太小儿科了太低级了

所以在这个方面呢

应该来说还是有

很多很多的工作需要去做的

这我刚才提到了就是说

我们为了实现

这方面的一些可扩展性

那么实际上它要去把

把这个传统的这个数据库里的

比如他去做（英文）

做（英文）完了之后呢

你可以在这个（英文）的基础上

它这个（英文）

有很多这种优化的一些

或者是一些能够自动的

去把这个做出来的

这样的一些方法

如果你想去自动

所以你在这个对于这个Data

（英文）这样的一些优化呢

你就可能就很难去完成了

那么实际上如果说

我们把这个限制给它去掉

我们的这个Data的

这个里头的结构

由我们自己来解释的话

那我们有可能能够做到

就是底层的这个平台

让它能够非常非常的

就是说能够去SQL的非常好

就是具体SQL实际上就是说

我一台机器做不了的时候

我拿两台机器做

我拿两台机器做不了的时候

我拿四台机器做

就这样不断的加

然后它的这种

比如它的这种（英文）

或者它的处理的这种量

能够也能够基本上线性的去增加

这是希望达到的这样的一个效果

这个底下就是一个最简单的

或者说一个最基本的

这样的一个（英文）

这样一个程序

实际上就是它要做的

比如说我有一个很大很大的

这样的一个词表

一个文本文件

我要去统计里头的每一个词

出现了多少回对吧

大家可能

这个（代码）如果去了解

看那个（英文）那一套东西的话

可能基本的就会都讲这个东西

它实际上就是说

我先去把这个文件

我把它分成块儿

然后每一个机器

每一块我会扔到一个机器上去

然后每一台机器呢

我就去分别统计

它那一块那样一些一个基数

然后最后根据这个key

实际上就是每个每个

这个（英文）

如果去把这个做一些（英文）

把这个结果

把它送到不同的这个机器上去

这个实际上就是在这个

如果是一个分布式数据库的话

大家可能就是知道

就是说做（英文）的时候

它要做这种Data的这种（英文）

它要把这个数据

分到不同的地方去

当然那个地方

因为它这个（英文）里头的

这种条件你可能要去

由系统自己来决定的话

它就没有办法决定的非常好

所以在这个地方

你用这个（英文）

它这个key怎么生成的

你可以自己去决定

所以在这儿分的时候

它可以容易达到一个

比较好的这样一个效果

你比如有一些词可能非常多

比如像一些（提供词）

可能非常多 对吧

它的这种量可能会非常大

你这儿可以做一些

特殊的处理

然后完了之后（英文）

就是说我可以把这些东西

然后让它最后

放到不同的（14：33）

能够比较平均的让它去完成

这样的话

最后得到这样的一个结果

这个就是说随着你的数据量

不管你多大

我可以加机器

通过加机器的方法

能够去把这个东西

把它给算出来

算出来 当然你

当然也可以从这个里头看到的

就是说这个中间有很多问题

实际就是说首先你写应用程序

你就得需了解

非常多的这种数据的

这样的一些细节

这是一个问题

第二个问题就是说

对于数据的这种访问

实际上数据库里头呢

有很多这种比如说这种（英文）

或者是它的这种（英文）

等等这方面的东西呢

在这个上面是完全没有了

完全没有了

你完全要去（英文）这个（英文）

这样的话就是说2009年的时候

就是我刚才提到了一个（英文）

他们写过一篇文章

就是他就比较

就是说这个数据库

当然它那个数据库

它不是一个（英文）的

一个数据库

它是一个叫MPP的

这样的一个（英文）

他们就比较这样的一个

处理性能上的这样的一个差异

最后发现就是（英文）这个东西

和这个MPP这样的（英文）

它这个性能上差别

可能能够达到一个数量级

所以这个性能的这个差别

是非常大的

但是它的这个东西的好处就是说

它能够 几乎能够

因为它通过这种key的这种方式

它把这些关联关系

强的这种关联关系把它给去掉了

所以基本上它能够扩充到

比如像hadoop能够最大的部署

现在应该是在几万台机器

这个规模

但是传统 就是说现在的

即使是最好的

这种MPP这种（英文）

它可能到几百台这种机器

因为它中间的这种Data（英文）

就是它这种Data（英文）

做（英文）的时候

它可能会把这个

网络的带宽都吃满

都吃满了之后你再想去再去

这个你即使往里头加机器

这个（英文）这些（英文）

它可能也都跑不下去

但是这个

在这个（英文）这个环境里

它就不一样

它可以即使是说

我有些CPU我用满了

我可以 仍然可以

通过系统的这种资源的

这样的分配

能够去把这个新的这些资源

纳入进来 来去让这些任务

能够跑下去

虽然它可能会跑的比较慢

这个就是说为什么这个NoSQL

它这方面的一些做法

它能够去提高这种系统的

这种可扩展的这个能力

然后随着这个NoSQL的这个发展

它也遇到另外一个问题

我刚才提到

它可能性能是一个问题

对吧

另外一个就是说

传统的这种SQL数据库

它实际上是有一个

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

叫这个ACID

ACID 它实际上就是说这种

事物执行的过程当中

它这种原则性

它这种一致性

它这种互相隔离

和它的这种持久的

这样的一些特征

中间的这个图

中间的这个图

实际上是一个非常著名的

这样的一个分布式系统的

这样的一个定理

叫（英文）一个教授

他在九十年代

应该是1997 1998

那几年提出来的

他讲就是这种就是三个

三个属性

一个是分布式系统

一个叫Consistency

就是实际上这种一致性

然后第二个是它这种可用性

第三个我们叫这个

英文叫（英文）

中文翻法可能会不一样

它可能基本上就是说

我这个网络断了

我这个系统是不是还能够

正常的工作

它讲就是说如何一个分布式系统

你只能 只能是保留其中的

某两个方面

你没有办法去做到

三个方面都能够面面俱到

那么实际上这一块呢

就是说这么传统（英文）

它选择是这种（英文）

它如果这个网络断的话

它要么就不工作了

它就是你一网络断

我就是为了保证这个Consistency

我可能就不提供服务了

这个（英文）它就没有了

当然现在新有的

就是这种NoSQL的

这样的一些东西呢

它实际上就是呢

它实际上就是放弃了

这个ACID这样的一些保证

就是说我不保证这个Consistency

我牺牲这个Consistency

是为了得到更好的这些（英文）

这什么意思呢

就是说我即使是网络断了

网络断了完了之后

我可以一个

比如说我有一个记录

有一个记录

我要写进去的时候

如果我要保证Consistency

我本来是希望说

我的所有的copy

我的所有的copy

应该都是能够同时

就是比如说通过这种T2C

这样的一些技术手段的

一个分布式的这样的一个协议

能够都改过来

那这种情况我说

我可能暂时能够容忍

比如说我这几个copy

它不一致 没关系

比如说我在购物的时候

我加了一个商品

到我的购物车里头

购物车里头呢 这个

但是一个后台的时候

后台它可能这个购物车

这个季度本来

比如说我有三个copy

因为某种原因

我只存了其中的一个

然后我在这个上面

看到的是其中的一个

然后另外一个

比如说我在另外一个设备

或者是另外一个装置上

我把这个我的购物车再打开

你可能它连着的

正好可能是另外一个copy

这种情况你可能看到

两个地方是不一致的

不一致的

然后甚至在

现在的有一些这种比较

就是以前看起来

就是这种交易相关的

这样的一些操作

比如说你在互联网上去转钱

这个又是我

我前一段我自己遇到的

这样的一个case

就是说在京东的

它有一个叫白条的

这样的一个 一个应用里头

我当时是它要还钱

就是跟信用卡还钱一样

当时还了 还了最后呢

我进去查

查完了之后

它一直说没还 没还这个状态

我说这个钱跑哪里去了

因为实际上是还了

但是它一直说

你这个还没有还

这样一个状态

后来它慢慢的慢慢的（英文）

最后这个结果最后回来

回来说你还完了

实际就说这种情况下

他实际上就是通过系统的

这样的一些内部的一些操作

就是说我要以（英文）

我保证你这个东西是一致的

但是在某些特定的

这种状况下面可能

你看到的可能

是一个不一致的这样的状态

所以这个就是在这种（英文）里头

它采取的这样的一个模型

后来这个英文有一个酸性的这样

就是碱性的这样

所以这个词

当然有点拼凑的意思叫（英文）

就说我基本上

它这个系统能够available就是可用的

但是它的这个（英文）

它不是一个（英文）

它可能在并不是

在任何情况下都是一个（英文）

就是一个恒定的持久的

这样的一个状态

而是一个有的状态

是一个中间状态

中间状态它可能

最终我能够让它做到（英文）

就是最终我能够保证

但系统比如说那些故障都没有了

或者是我的（英文）都处理完了之后

它的这种状态能够达到一致

就是这种数据的状态

能够达到一致

所以这个就是说从

再去构建（英文）的时候

可能以前的这样的一些

传统的数据库里的（英文）

就是很好很好的（英文）

但是这个仍然是在很多情况下

我们所希望达到的这样的一个东西

但是为了（英文）

或者是扩充的这样的一些能力

我们做了一些调整

做了一些调整仍然是它能够满足

就是说一些基本的这样一些需求

虽然可能和以前看到的行为

比如说我刚才说的转帐的那个案例

它有一点点不一样

但是基本上是说我不太影响

这个业务的

这样的一个实际的运营

这个就是说从因为从（英文）到（英文）

然后它在这个系统

或者是应用感到的

这样的一些行为

比如系统提供的这样的服务

或者我们叫（英文）方面的一些变化

这是一个比较大的

这样的一个变化

然后那么我刚才

最早我题目叫挑战对吗

实际上这个事情是不是做完了

就说（英文）发展到现在

当然取得了非常非常大的

这样的一些成就

但实际上它离就是真正的

这样的一个完美的

这样的一个数据平台

实际上还有很多很多的距离

比如说我刚才提到的就是说

在现在很多（英文）里头

那个传统的数据库

它的很多行之有效的

比如说像INDEX这样一些做法

实际上在数据库里头它是没有的

然后对于比如说这种SQL

这样的一些支持

现在也是非常非常初级的

然后当然再比如说这个（英文）

这方面的一些要求的话

实际上可能能够做的事情更多

我在这里大概列了一下

就说我们可以看到实际上

就我刚才提到发展的过程中间

有一个（英文）的这样的应用

这个实际上就是一个

就是在互联网上

这样一个协作的这样的一个案例

就是说什么意思

就说两个人

互相坐到自己的机器上面

然后可能隔着通过网络

然后他们协同的

去编辑这样的一个文档

比如说这个简单的一个ABC

这样一个串

然后这种情况下

它会有一些这种需求

就是说如果我们每一个动作

比如说每个按键我都要去

和远程的一个机器做协调的话

这个延迟可能是在多少个秒

那这种情况

你基本上就是你按一个键

你可能要等一会儿它才能够出来

它的效果才能够出来

这种情况下很多情况

你可能用两下你就不愿意用了

所以基本上

你打一个键马上就能出来

所以基本上一些比较新的

这样的一个协作性的

它基本上采取的一个策略就是说

我每次按键的时候

我自己本地的

我就把这个操作给它做了

然后后台通过这样的一些传输

然后把这个操作然后（英文）到

其他的合作的

这样的一些站点上面去

然后远程的站点也是这样

所以基本上就说

每一个本地这样的copy

就是说我们可以把这个文档

看成是一个对象通过复本

那么每一个操作在本地做的时候

我希望它能尽快的完成

然后复制到远方去的时候

这个问题就出来了

就是说你看如果在这儿

我把它变成了它是这样两个状态

就说我把这儿加了个X

然后这个地方它变成了

我把它删掉一个数

你如果这个操作

原封不动的并过来的话

它这个地方它就会变成是

在这操作来了它变成0

就说你如果不做变化的话

它还是这个0到X

那么我能够把这儿

加到这个地方去

当然如果你这个操作

你不做变化了

它实际上最后变成了是一个这个R

R实际上应该是是0 1 2应该是个B

所以它变成Xac了

所以这种情况就是说

为了保证这个操作的

这个操作效果能够达到一致

一般情况它会根据

这样的一个操作这样一些特点

然后把这个操作

就是这个站点发过的操作

把它变成一下

基本上就是把它变成是一个

变成去把3这个位置的字母

最后删掉 然后变成了sab

然后这儿也变成sab

当然这个东西你可以看起来

好像听起来是一个

非常非常（英文）这样的一个操作

因为什么呢

就是说在这个模型下面

我们实际上

可以看到就是这个文档

它实际上是把它当成是一个

字符的这样的一个数组 对吗

然后上面考虑的

两个主要的操作

比如一个（英文）一个（英文）

它会影响这个（英文）和（英文

）后面的这些字符的

这样的一个分布的这样的一个情况

然后在这个基础上

就说考虑这样的

一个简单的对象的模型

然后上面的

这个简单的几个操作

然后实际上做OT

从80年代做到现在

实际上是也没完全做明白

因为它这个操作你最后发现

这是一个最简单的情况

就说这两个

实际上你会发现

人如果这个站点太多

然后这个操作之间的这种交织的

这种关系越来越复杂的时候

你做这种

就是两个两个之间的这种转换

在很多情况下它操作

（英文）这种关系复杂完了以后

你转换出来的结果仍然是不对的

所以在这种情况下也就是说

我为什么举这个例子

这个例子实际上就是在这种（英文）

它底下就是说我要买（英文）

为了这种可用性（英文）

然后它去保证（英文）之间的

这样的一个一致性

这个协作里头的

实际上是一个非常典型的

跟那个非常类似的这样的案例

然后它的这个模型

是一个非常特殊的模型

就是它是一个数组

然后上面就这么两个操作

然后大家玩了几十年

也没把它玩明白

那么实际上后来

也有很多人在这么动脑筋

另外我们比如说

我们去写一个应用

写一个应用

我们底层用的这些数据模型

可能是千变万化的

你去定一个数据结构

各种各样的结构可能都有

有可能是一个数组

也有可能是一个记录

也有可能是一些

比如说一些数据上的（英文）（英文）

或者（英文）等等这样的一些结构

那么针对这样的一些结构你怎么能够

实际上就是有一个基本的一个

或者一个理想的状况

我怎么能够说我有了这个结构

我上边有一些操作

我就不用去关心

我这个操作我就随便往上发就好了

其实系统就是断掉了

断掉了

当你这个操作传到（英文）的时候

我仍然能够保证它一致

你系统自动这么做

这是个理想的状况

可能大家如果说

有这样一个系统的话

可能大家都会愿意去用它

因为什么呢

就说我不用再去关心

底层的一些细节性的一些东西

实际上就是说做这些OT的这样一些操作

大家可能挠破了头

现在也没搞明白

那么现在就出来一些新的技术叫（英文文）

它就是想做这个事

但是它现在你做的任意的

这样的一个结构都能够去

或者任意的结构任意的操作都

能够说我让系统来（英文）

这个可能是不可能的

因为你有这点可能

就说它以为操作

你可能不管你怎么处理

它仍然是做不到一致的

这种情况下就说我们可以在

但是一如果加一些特定的一些限制

比如说这种（set）

或者其他的这样一个东西

然后能够去让它

在某些特定的操作里变

比如说我就像一个（英文）一样

或者去做这种加法

或者求它一些其他特定的一些

这种情况下在某些特定的情况下

它是可以做到的

就是系统自动来做这个事

而且可以用这种

比如说这种叫（英文）

我（英文）或者说我去通过（英文）

这个（英文）然后在操作这个基础上

我去做这样一些事

能够让它最后的这个状态能够（英文）

这是可以做得到的

但是（英文）这个事情到底怎么样

现在来看的话

仍然是一个没有解决的问题

但是我觉得是一个

非常有意思的这样的一个问题

这是从（英文）

发展的这样一个情况来看的话

也就是说可能还会有很多很多

这样的一些工作需要来完成