新手如何理解 SPL 运算

作为结构化计算引擎,SPL 带来了很多全新的概念,其内容远远超出以关系代数为基础的传统体系。熟悉 SQL 或者 Java 的同学,初次接触 SPL 时对此比较陌生,参考本文可以准确理解这些新概念,快速掌握 SPL 的关键概念。

离散性及普遍集合

在 SPL 中,记录是一种基本数据类型,数据表是记录构成的集合。构成数据表的记录可以游离于数据表之外独立、反复使用,我们称为游离记录

比如要计算员工表中的 Jack 和 Rose 的年龄差和工资差,SPL 的代码大致是这样的:


A

B

1

=file("employee.btx").import@b(name,age,salary)

2

=A1.select@1(name=="Jack")

=A1.select@1(name=="Rose")

3

=A2.age-A3.age

=A2.salary-A3.salary

A2 和 B2 分别按照条件过滤出需要的记录,这两条记录游离于员工表之外,可以独立使用。在 A3、B3 中,就是使用这两条游离记录完成了多次计算。

需要注意的是,游离记录 A2、B2 并不是将原记录另外复制一份,而是直接引用了原记录。这样做可以避免复制过程消耗额外的时间,而且可以减少空间占用。

SPL 的游离记录还可以通过计算构成新集合,也就是新数据表。比如常见的交集、并集、差集等集合运算。仍以员工表为例,下面的SPL 代码可以计算出多种集合运算结果:


A

B

1

=file("employee.btx").import@b(name,dept,gender,salary)

2

=A1.select(gender=="F")

=A1.select(salary>=4000)

3

=A2^B2

=A2\B2

4

=A2&B2


A2 和 B2 分别过滤取出了女员工和薪酬在 4000 及以上的员工,构成了两个新的集合。

A3 对两个集合求交集,结果是薪酬在 4000 及以上的女员工。B3 对两个集合求差集,结果是薪酬在 4000 以下的女员工。A4 对两个集合求并集,结果是全部女员工和薪酬在 4000 及以上的男员工。这些集合运算都有实际的业务意义。

而且,参加这些集合运算的都是 A1 序表的游离记录,没有发生记录的复制。

实际上,上面这种游离记录的观念在 Java 和 C++ 等高级语言中很常见,但 SQL 却没有。

SQL 的理论基础关系代数定义了丰富的集合运算,但是离散性非常差,没有游离记录。Java 等高级语言没有离散性的问题,但是对集合运算的支持却很差。SPL 集中了 SQL 和 Java 两者的优势,将离散性和集合化结合起来,既有集合数据类型及相关的运算,也有集合成员游离在集合之外单独运算或再组成其它集合。

离散性和集合化非常重要,这也是 SPL 的理论基础被命名为“离散数据集”的原因,初学 SPL 的同学要重点理解这两个概念。SPL 在离散性的支持下,提倡普遍集合,并应用于分组、聚合、有序和关联等多种运算场景,下面我们将在相关内容中分别介绍。

Lambda 语法

和 SQL 类似,SPL 也提供了 Lambda 语法,并且进行了扩展,掌握 SPL 的 Lambda 语法对于熟悉使用它非常重要。

如果普通函数 f(x) 的参数是表达式,那么执行的时候会先将表达式计算好,然后再计算函数 f。比如 max(3+5,2+1),要先计算好 3+5 和 2+1 再计算 max(8,3)。如果参数中含有变量,类似 max(x+5,y+1) 这样的表达式,在 x 和 y 没有被赋值时是无法计算的,而 x 和 y 被赋值后也会把 x+5 和 y+1 先计算出来再传入给 max 函数去计算。

但是,有些函数的参数表达式无法提前计算出来。比如前面用 A1.select(gender=="F") 函数来过滤性别为女的员工,gender=="F" 在执行 select 函数之前是无法计算的。这是因为 gender 在对 A1 这个集合的成员做循环计算的时候才能确定,然后才能计算这个表达式。

这时,我们是将整个表达式作为参数传递给 select 函数去执行的,也就是定义了一个临时函数作为 select 函数的参数,这种写代码的方法称为Lambda 语法。类似 select 这样的函数,SPL 称为循环函数。循环函数的本质特征是以函数为参数。

SQL 在针对数据表运算时可以将表达式作为语句的参数,实现了基本的 Lambda 语法。比如:

select * from employee where gender='F'

WHERE 条件中的表达式 gender='F',也不是在执行这个语句之前先计算好的,而是在遍历时针对每条记录计算的,对于 WHERE 运算而言,相当于把一个用表达式定义的函数作为了 WHERE 的参数。

SPL 进一步丰富了 Lambda 语法,可以针对任何集合使用,而且,还提供了符号用于引用当前成员及其序号以及相邻成员,这样可以进一步简化代码的书写。

比如集合中存储了某公司 1 到 12 月的销售额,我们可以做下面这样的计算:


A

1

=[820,459,636,639,873,839,139,334,242,145,603,932]

2

=A1.select(#%2==0)

3

=A1.(if(#>1,~-~[-1],0))

A2 过滤出偶数月份的销售额,A3 则计算每月销售额的增长值。

其中的 #表示循环计算时当前成员的序号。~ 表示当前成员,~[-1] 表示当前成员的上一个成员。一般的,[-i] 表示当前成员向前 i 个成员,[i] 则表示向后 i 个成员。

数据表也是集合,同样可以使用 ~、# 和 [] 符号直接引用集合中的成员。比如某公司月销售表,除了 12 个月销售额之外,还有每个月的综合成本,我们可以做下面这些计算:


A

1

=file("sales.btx").import@b(month,sales,costs)

2

=A1.(~.sales-~.costs).min()

3

=A1.(if(#>1,~.sales-~[-1].sales,0)).max()

A2 计算销售额和成本之差的最小值。A3 计算销售额每月增长的最大值。

对于数据表来说,集合的成员就是记录,所以当前记录的字段要写成 ~.sales。很多情况下 ~ 可以省略,比如 ~.sales-~[-1].sales 可以写成 sales-sales[-1]。

关于 ~、#、[] 等符号的深入思考,可以参考 【程序设计】5.7 [一把抓] Lambda 语法

JAVA 语言中出现的 Stream 和 Kotlin 也开始支持 Lambda 语法,但没有针对结构化数据做特殊设计,只能把当前记录作为参数传入用 Lambda 语法定义的函数,引用当前成员的字段时,总要带上这个记录。比如用销售额和成本计算利润时,如果用于表示当前成员的参数名为 x,则需要写成 “x.sales - x.costs”,不能直接写字段名。JAVA 也没有 SPL 的 ~,#,[] 符号。

有序性和位置利用

SPL 数据表是个有序集合,其中的记录按顺序从 1 开始编序号,记录的序号表示该记录在有序集合中的位置,这就是有序性

利用有序性,我们可以用序号来访问某个位置上的记录,还可以对相邻的记录做计算。比如预先将某只股票的股价数据按照交易日期有序存储,利用位置计算的 SPL 代码就是下面这样:


A

B

1

=file("stock.btx").import@b(sdate,price)

2

=A1(1)

=A1.m(-1)

3

=A1.pselect@1(sdate==date("2022-10-11"))

4

=A1.m(A3-1)

= A1.m(A3).price- A4.price

5

=A1.derive(~.price-~[-1].price)

A2 取得第一条记录,是第一个交易日的数据。B2 取得最后一条记录,是最近一个交易日的数据。m() 函数的参数为负数表示倒数第几个成员。

A3 查找 2022-10-11 的记录序号。A4 按序号取出 A3 的前一条记录,是上一个交易日数据。B4 计算 2022-10-11 价格比上一个交易日涨了多少。

A5 计算每个交易日的价格比上个交易日上涨了多少。

有了有序性和位置利用,再加上 ~、# 和 [] 等符号,这些原本很难描述的计算,也变得非常简单、直观了。

有序性运算是典型的离散性与集合化的结合场景。次序的概念只有在集合中才有意义,单个成员无所谓次序,这体现了集合化;而有序计算又需要针对某个成员及其相邻成员进行计算,需要离散性。

关系代数是基于无序集合设计的,集合成员没有序号的概念,也没有提供定位计算以及相邻引用的机制。SQL 实践时在工程上做了一些局部完善,使得现代 SQL 能进行一部分有序运算。但是,很常见的有序运算却仍然是 SQL 的困难问题,即使在有了窗口函数后还是很繁琐。SPL 则大大改善了这个局面。

SPL 有序性是 SQL 没有的概念,也是初学者要重点学习的。利用有序性可以让复杂的计算变得很简单,也可以让很慢的计算变得飞快,后边的介绍会涉及到一些,更多内容请参考乾学院上的介绍。

分组和聚合理解

有了离散性和彻底的集合化,SPL 支持集合的集合。因此,SPL 可以实现更本质的分组运算,也就是将大集合按照一定规则分拆为若干子集合,分组结果是由这些分组子集组成的一个新集合。

很多情况下,分组后要对子集做聚合计算,比如求和、求平均、求最大值等等。但是,聚合并不是分组的唯一目的。比如我们想找出公司里有哪些员工和其他员工会在同一天过生日,很简单的思路是将员工按生日分组,然后找出成员数大于 1 的分组子集,再合并起来。这时候我们就不是只对聚合值(分组子集的成员数)感兴趣,而是对分组子集本身更感兴趣。在 SPL 中,分组的返回值是分组子集,意味着分组和聚合被拆分成了相互独立的运算,很容易完成这个思路,具体代码大致是这样的:


A

1

=file("employee.btx").import@b(name,dept,birthday)

2

=A1.group(month(birthday),day(birthday))

3

=A2.select(~.len()>1)

4

=A3.conj()

A2:对员工表这个大集合分组,结果是若干小集合,也就是分组子集。有了离散性的支持,分组子集仍然是原集合(员工表)的成员构成,记录并没有被复制。

由于人们一般认为两个人生日的月、日都相同就是同一天生日,所以这里的分组字段是生日的月、日。

A3:过滤出这些子集中有 1 个以上成员的,也就是有生日相同的员工。

A4:合并过滤的结果。

还有些情况下,要对一种分组方式计算出多种聚合值。由于 SPL 分组计算能得到并保持分组子集,我们可以利用这些分组子集,反复计算出多种聚合值。分组运算的成本不低,这样做可以避免重复计算分组,有利于提升计算性能。比如我们计算每个部门的人数,再计算出 10 人以上部门的人员平均工资。SPL 代码大致是这样的:


A

1

=file("employee.btx").import@b(dept,salary)

2

=A1.group(dept)

3

=A2.new(~.dept,~.len())

4

=A2.select(~.len()>=10).new(~.dept,~.avg(salary))

A2:按照部门 dept 分组,结果是多个分组子集,每个分组子集就是一个部门的员工集合。

A3:循环计算出每个分组子集的部门和子集的成员个数。~ 符号代表 A2 分组结果中的当前行,也是就是一个分组子集。

A4:再次利用 A2 的分组结果,过滤出分组子集的成员个数大于等于 10 的,计算每个子集的 dept 和平均薪酬。

SPL 将分组和后续的聚合拆开,还可以应用在其他很多场景中。比如有些聚合需求很难计算,要对分组的结果再写段代码才能算出来;或者数据分组后,还要对分组子集再做分组的情况等等。

与 SPL 相比,SQL 没有显式的集合数据类型,无法返回集合的集合这类数据,不能实现独立的分组,就只能强迫分组和聚合作为一个整体来计算了。

SPL 将任何拆分大集合的方法都看作分组运算。除了常规的等值分组外,还提供了可能得到不完全划分结果的对位分组枚举分组,请参考乾学院的其他文章进一步学习。

理解了离散性和集合化在分组运算上的应用,我们再来看有序性如何大幅提高分组计算的性能。通常的分组运算是用 HASH 算法实现的,如果我们确定地知道数据对分组字段有序,则可以只做相邻对比,避免计算 HASH 值,也不会有 HASH 冲突的问题,而且非常容易并行。在上一个例子中,如果我们预先将员工表按照部门排序存放,在分组计算时就可以仅比较相邻的记录,部门相同的归并成一组,这种方法称为有序分组。有序分组的复杂度降低了很多,性能提升非常明显。代码只要稍作修改:


A

1

=file("employee.btx").import@b(dept,salary)

2

=A1.group@o(dept)

3

=A2.new(~.dept,~.len())

4

=A2.select(~.len()>=10).new(~.dept,~.avg(salary))

A2 group 函数使用 @o 选项,仅合并相邻的部门号做分组。

SPL 对聚合运算也有新的理解,聚合结果除了常见的单值 SUM、COUNT、MAX、MIN之外,也可以是个集合。比如常常出现的 TOPN 计算,SPL 也看作和 SUM、COUNT 一样的聚合计算,既可以针对全集也可以针对分组子集。比如我们要计算员工表薪酬最低的 TOP10,还要计算每个部门薪酬最高的 TOP3,SPL 代码大致是下面这样:


A

1

=file("employee.btx").import@b(name,dept,salary)

2

=A1.top(10;salary)

3

=A1.groups(dept;top(-3;salary):top3)

4

=A3.conj(top3)

A2 计算员工表的薪酬最低的 TOP10。A3、A4 计算每个部门的薪酬最高的 TOP3。

关系代数无法把 TOPN 运算看成是聚合,针对全集的 TOPN 只能在输出结果集时排序后取前 N 条,而针对分组子集则很难做到 TOPN,需要转变思路拼出序号才能完成。SPL 把 TOPN 理解成聚合运算后,在工程实现时还可以避免全量数据的排序,从而获得高性能。而 SQL 的 TOPN 总是伴随 ORDER BY 动作,理论上需要大排序才能实现,只能寄希望于数据库在工程实现时做优化。

游标

为了处理大数据,SPL 也提供有游标,其基本功能和数据库游标有类似之处,都是按顺序读取数据。不同点是,SPL 是从文件中读取,每次可以读取一批数据。比如要统计订单表的总金额、总笔数和平均金额,SPL 采用循环读取订单表游标的代码大致是这样的:


A

B

C

1

=0

=file("orders.ctx").open().cursor(amount)

=0

2

for B1,10000

>A1+=A2.len()


3


>C1+=A2.sum(amount)


4

=C1/A1



除了循环读取数据的基本能力之外,SPL 游标提供了比 SQL 游标更强大的功能。比如 SPL 定义了丰富的游标函数,可以在游标上附加各种运算,要计算金额大于 5000 的订单总金额和订单数,SPL 代码可以写成这样:


A

1

=file("orders.ctx").open().cursor(amount)

2

=A1.select(amount>5000)

3

=A2.groups(;sum(amount):S,count(amount):C)

4

=A3.S/A3.C

A2、A3 在游标上附加了两个步骤的计算:先过滤出金额大于 5000 的订单,再求总金额和总数。

虽然游标是外存计算,和内存计算本质上是不同的。但是,从这个例子可以看出,SPL 游标函数设计的尽量和内存函数很像,这样在学习和编程上都会方便很多。

需要初学者重点理解的是,这个例子 A2 中的 select 函数并不会真的将金额大于 5000 的订单先过滤出来,只是在游标上定义了过滤计算。等到下一步 groups 函数遍历数据的时候,SPL 才会执行预先定义好的 select 动作,也就是读入一批数据先做过滤再做汇总,然后再读入下一批数据。

我们称 select 函数返回的这种游标为延迟游标,它只有在真正取数据时才会执行实质性的计算。而 groups 函数则会立即触发游标遍历动作,且返回的也不再是游标,称为立即计算学习游标函数时,要了解其返回值,知道它是不是延迟游标。

延迟游标的好处是中间结果不用落地。比如这个例子中的过滤计算如果先算出结果,可能内存仍然装不下,只能写硬盘供下一步计算读取。而读写硬盘的时间会很慢,远远不如延迟游标的计算性能。

与数据库游标相比,SPL 还支持多路游标,很容易实现并行计算;支持遍历复用,可以对游标遍历一次时计算出多种结果。还有针对复杂计算的程序游标和支持横向扩展的集群游标等等,在乾学院中都有详细的介绍。

连接理解

SQL 对 JOIN 的定义是两个集合(表)做笛卡尔积后再按某种条件过滤。这种过于简单的定义无法充分体现不同 JOIN 的运算特征,在运算较为复杂时,无论书写还是优化都非常困难

实际应用中,绝大多数 JOIN 都是等值关联,也就是关联条件为等式的 JOIN。SPL 将等值 JOIN 运算分成外键关联同维表关联主子表关联三种情况分别处理,由程序员根据不同的场景来选择使用不同的计算方法。这样做可以体现数据之间的关联特征,并能针对不同的特征采取不同的手段,有效简化语法、提高性能。

外键关联是指用一个表的非主键字段,去关联另一个表的主键,前者称为事实表,后者为维表。比如下图中的订单表是事实表,客户表、产品表、雇员表是维表。

..

对于外键关联计算,SPL 提供了一个自然直观的办法:外键地址化。将订单表和雇员表关联后,按照雇员姓名和订单日期来过滤订单数据的代码就是下面这个样子


A

B

1

=file("employee.btx").import@b().keys@i(eid)

=file("orders.btx").import@b()

2

>B1.switch(eid,A1:eid)


3

=B1.select(eid.name=="Tom" && odate=…)

A2中,将订单表中的雇员(eid)字段转换为雇员表的一条记录,也就是完成了外键地址化。A3 计算时就可以用 eid.name 来引用这条记录中的姓名字段,其中的点操作符含义是地址引用。

同维表关联是指两个表通过主键关联。比如下图中员工表和经理表就互为同维表,员工表的主键 eid 和经理表的主键 mid 关联,有部分员工是经理,eid 和 mid 都是员工编号。同维关联是一对一的关联。

..

SPL 用 join 函数来实现同维表连接。比如要查询每个员工(包括经理)的编号、姓名和总收入(工资加津贴),代码是这样的:


A

B

1

=file("employee.btx").import@b().keys(eid)

=file("manager.btx").import@b().keys(mid)

2

=join@1(A1:e,eid;B1:m,mid)


3

=A2.new(e.eid:eid,e.name:name,e.salary+m.allowance:income)

主子表关联是一个表的主键去关联另一个表主键的一部分,比如下图中订单表主键是订单号 oid,明细表主键是订单号 oid 和产品号 pid 两个字段。订单表的主键 oid 与明细表的部分主键 oid 关联。订单表是主表,明细表是子表,两者是一对多关系。

..

主子关联时 SPL 也使用 join 函数来处理。比如我们想计算每个客户的订单总金额,代码是这样的:


A

B

1

=file("orders.btx").import@b()

=file("order_detail.btx").import@b()

2

=join(A1:o,oid;B1:od,oid)


3

=A2.groups(o.cid:cid;sum(od.price*od.quantity))

与同维表关联不同的是,oid 只是明细表的部分主键,明细中可能会有 oid 相同的多条记录。这时候 join 函数的结果中订单记录会重复出现,每一条明细记录都会关联一条订单记录,而每一条订单记录则会关联多条明细记录,最后的结果的记录数和明细表相同。

SQL 对多种 JOIN 场景笼统的处理,而 SPL 则要区别对待,对不同的 JOIN 采用不同的函数来计算,大数据场景下做 JOIN 的性能优化时也需要采用不同的手段甚至不同的存储方式。初学 SPL 的同学要重点理解 SPL 对连接运算的新观念,在需要做连接运算时,识别出 JOIN 属于什么类型,再选择相应的方法实现。更详细的内容参见乾学院的相关介绍。


以下是广告时间

对润乾产品感兴趣的小伙伴,一定要知道软件还能这样卖哟性价比还不过瘾? 欢迎加入好多乾计划。
这里可以低价购买软件产品,让已经亲民的价格更加便宜!
这里可以销售产品获取佣金,赚满钱包成为土豪不再是梦!
这里还可以推荐分享抢红包,每次都是好几块钱的巨款哟!
来吧,现在就加入,拿起手机扫码,开始乾包之旅



嗯,还不太了解好多乾?
猛戳这里
玩转好多乾