轻量级内存计算引擎

内存计算指数据事先存储于内存,各步骤中间结果不落硬盘的计算方式,适合性能要求较高,并发较大的情况。

HANATimesTen等内存数据库可实现内存计算,但这类产品价格昂贵结构复杂实施困难,总体拥有成本较高。本文介绍的集算器同样可实现内存计算,而且结构简单实施方便,是一种轻量级内存计算引擎。

下面就来介绍一下集算器实现内存计算的一般过程。

一、        启动服务器

集算器有两种部署方式:独立部署、内嵌部署,区别首先在于启动方式有所不同。

l   独立部署

作为独立服务部署时,集算器与应用系统分别使用不同的JVM,两者可以部署在同一台机器上,也可分别部署。应用系统通常使用集算器驱动(ODBCJDBC)访问集算服务,也可通过HTTP访问。

n   Windows下启动独立服务,执行安装目录\esProc\bin\esprocs.exe”,然后点击启动按钮。

                                              undefined

n   Linux下应执行安装目录/esProc/bin/ServerConsole.sh”

启动服务器及配置参数的细节,请参考:http://doc.raqsoft.com.cn/esproc/tutorial/fuwuqi.html

 

l   内嵌部署

作为内嵌服务部署时,集算器只能与JAVA应用系统集成,两者共享JVM。应用系统通过JDBC访问内嵌的集算服务,无需特意启动。

详情参考http://doc.raqsoft.com.cn/esproc/tutorial/bjavady.html

二、        加载数据

加载数据是指通过集算器脚本,将数据库、日志、WebService等外部数据读入内存的过程。

比如Oracle中订单表如下:

订单ID(key)

客户ID

订单日期

运货费

10248

VINET

2012-07-04

32.38

10249

TOMSP

2012-07-05

11.61

10250

HANAR

2012-07-08

65.83

10251

VICTE

2012-07-08

41.34

10252

SUPRD

2012-07-09

51.3

订单明细如下:

订单ID(key)(fk)

产品ID(key)

单价

数量

10248

17

14

12

10248

42

9

10

10248

72

34

5

10249

14

18

9

10249

51

42

40

将上述两张表加载到内存,可以使用下面的集算器脚本(initData.dfx):


A

1

=connect("orcl")

2

=A1.query("select   订单ID,客户ID,订单日期,运货费 from 订单").keys(订单ID)

3

=A1.query@x("select   订单ID,产品ID,单价,数量 from 订单明细") .keys(订单ID,产品ID)

4

=env(订单,A2)

5

=env(订单明细,A3)

A1:连接Oracle数据库。

A2-A3:执行SQL查询,分别取出订单表和订单明细表。query@x表示执行SQL后关闭连接。函数keys可建立主键,如果数据库已定义主键,则无需使用该函数。

A4-A5:将两张表常驻内存,分别命名为订单和订单明细,以便将来在业务计算时引用。函数env的作用是设置/释放全局共享变量,以便在同一个JVM下被其他算法引用,这里将内存表设为全局变量,也就是将全表数据保存在内存中,供其他算法使用,也就实现了内存计算。事实上,对于外存表、文件句柄等资源也可以用这个办法设为全局变量,使变量驻留在内存中。

 

脚本需要执行才能生效。

对于内嵌部署的集算服务,通常在应用系统启动时执行脚本。如果应用系统是JAVA程序,可以在程序中通过JDBC执行initData.dfx,关键代码如下:

1.       com.esproc.jdbc.InternalConnection con=null;

2.       try {

3.           Class.forName("com.esproc.jdbc.InternalDriver");

4.             con   =(com.esproc.jdbc.InternalConnection)DriverManager.getConnection("jdbc:esproc:local://");

5.             ResultSet rs = con.executeQuery("call   initData()");

6.       } catch (SQLException e){

7.           out.println(e);

8.       }finally{

9.           if   (con!=null) con.close();

10.   }

这篇文章详细介绍了JAVA调用集算器的过程http://doc.raqsoft.com.cn/esproc/tutorial/bjavady.html

如果应用系统是JAVA WebServer,那么需要编写一个Servlet,在Servletinit方法中通过JDBC执行initData.dfx,同时将该servlet设置为启动类,并在web.xml里进行如下配置:

 <servlet>
     <servlet-name>myServlet</servlet-name>
     <servlet-class>com.myCom.myProject.myServlet   </servlet-class>
   
 <load-on-startup>3</load-on-startup>
    </servlet>

 

对于独立部署的集算服务器,JAVA应用系统同样要用JDBC接口执行集算器脚本,用法与内嵌服务类似。区别在于脚本存放于远端,所以需要像下面这样指定服务器地址和端口:

st = con.createStatement();

st.executeQuery("=callx(\“initData.dfx\”;[\“127.0.0.1:8281\”])");

如果应用系统非JAVA架构,则应当使用ODBC执行集算器脚本,详见http://doc.raqsoft.com.cn/esproc/tutorial/odbcbushu.html

 

对于独立部署的服务器,也可以脱离应用程序,在命令行手工执行initData.dfx。这种情况下需要再写一个脚本(如runOnServer.dfx):


A

1

=callx(“initData.dfx”;[“127.0.0.1:8281”])

然后在命令行用esprocx.exe调用runOnServer.dfx

D:\raqsoft64\esProc\bin>esprocx   runOnServer.dfx

Linux下用法类似,参考http://doc.raqsoft.com.cn/esproc/tutorial/minglinghang.html

三、        执行运算获得结果

数据加载到内存之后,就可以编写各种算法进行访问,执行计算并获得结果,下面举例说明:以客户ID为参数,统计该客户每年每月的订单数量。

该算法对应的Oracle中的SQL语句如下:

select   to_char(订单日期,'yyyy') AS 年份,to_char(订单日期,'MM') AS 月份, count(1) AS 订单数量

from   订单  

where客户ID=?

group   by to_char(订单日期,'yyyy'),to_char(订单日期,'MM')

在集算器中,应当编写如下业务算法(algorithm_1.dfx


A

1

=订单.select@m(客户ID==pCustID).groups(year(订单日期):年份, month(订单日期):月份;count(1):订单数量)

为方便调试和维护,也可以分步骤编写:


A

1

=订单.select@m(客户ID==pCustID)

2

=A1.groups(year(订单日期):年份, month(订单日期):月份;

count(1):订单数量)

A1:按客户ID过滤数据。其中,订单就是加载数据时定义的全局变量,pCustID是外部参数,用于指定需要统计的客户ID,函数select执行查询。@m表示并行计算,可显著提高性能。

A2:执行分组汇总,输出计算结果。集算器默认返回有表达式的最后一个单元格,也就是A2。如果要返回指定单元的值,可以用return语句

pCustID=”VINET”时,计算结果如下:

年份

月份

订单数量

2012

7

3

2012

8

2

2012

9

1

2013

11

4

 

需要注意的是,假如多个业务计算都要对客户ID进行查询,那不妨在加载数据时把订单按客户ID排序,这样后续业务算法中就可以使用二分法进行快速查询,也就是使用select@b函数。具体实现上,initData.dfxSQL应当改成:

=A1.query("select   订单ID,客户ID,订单日期,运货费 from 订单 order by 客户ID")

相应的,algorithm_1.dfx中的查询应当改成:

=订单.select@b(客户ID==pCustID)

 

执行脚本获得结果的方法,前面已经提过,下面重点说说报表,这类最常用的应用程序。

由于报表工具都有可视化设计界面,所以无需用JAVA代码调用集算器,只需将数据源配置为指向集算服务,在报表工具中以存储过程的形式调用集算器脚本。

对于内嵌部署的集算服务器,调用语句如下:

call algorithm_1(”VINET”)

由于本例中算法非常简单,所以事实上可以不用编写独立的dfx脚本,而是在报表中直接以SQL方式书写表达式:

=订单.select@m(客户ID==VINET).groups(year(订单日期):年份, month(订单日期):月份;count(1):订单数量)

对于独立部署的集算服务器,远程调用语句如下:

=callx(“algorithm_1.dfx”,”VINET”;[“127.0.0.1:8281”])

 

有时,需要在内存进行的业务算法较少,而web.xml不方便添加启动类,这时可以在业务算法中调用初始化脚本,达到自动初始化的效果,同时也省去编写servlet的过程。具体脚本如下:


A

B

1

if   !ifv(订单)

=call("initData.dfx")

2

=订单.select@m(客户ID==pCustID)


3

=A2.groups(year(订单日期):年份, month(订单日期):月份;

count(1):订单数量)


A1-B1:判断是否存在全局变量订单明细,如果不存在,则执行初始化数据脚本initData.dfx

A2-A3:继续执行原算法。

 

四、        引用思维

       前面例子用到了select函数,这个函数的作用与SQLwhere语句类似,都可进行条件查询,但两者的底层原理大不相同。where语句每次都会复制一遍数据,生成新的结果集;而select函数只是引用原来的记录指针,并不会复制数据。以按客户查询订单为例,引用和复制的区别如下图所示:

 

undefined

可以看到,集算器由于采用了引用机制,所以计算结果占用空间更小,计算性能更高(分配内存更快)。此外,对于上述计算结果还可再次进行查询,集算器中新结果集同样引用最初的记录,而SQL就要复制出很多新记录。

除了查询之外,还有很多集算器算法都采用了引用思维,比如排序、集合交并补、关联、归并。

五、        常用计算

回顾前面案例,可以看到集算器语句和SQL语句存在如下的对应关系:

计算

SQL

集算器

查询

select

select

条件

Where….订单.客户ID=?

订单ID.客户ID==pCustID

分组汇总

group   by

groups

 

日期函数

to_char(订单日期,'yyyy')

year(订单日期)

别名

AS   年份

:年份

事实上,集算器支持完善的结构化数据算法,比如:

l   GROUP BY…HAVING


A


1

=订单.groups(year(订单日期):年份;count(1):订单数量).select(订单数量>300)


 

l   ORDER BY…ASC/DESC


A


1

=订单.sort(客户ID,-订单日期)

/排序只是变换了记录指针的次序,并没有复制记录

l   DISTINCT


A


1

=订单.id(year(订单日期))

/取唯一值

2

=A1.(客户ID)

/所有出现值

3

=订单.([ year(订单日期),客户ID])

/组合的所有出现值

l    UNION/UNION ALL/INTERSECT/MINUS


A


1

=订单.select(运货费>100)


2

=订单.select([2011,2012].pos(year(订单日期))


3

=A2|A3

/UNION   ALL

4

=A2&A3

/UNION

5

=A2^A3

/INTERSECTION

6

=A2\A3

/DIFFERENCE

SQL的交并补不同,集算器只是组合记录指针,并不会复制记录。

l   SELECT … FROM (SELECT …)


A


1

=订单.select(订单日期>date("2010-01-01"))

/执行查询

2

=A1.count()

/对结果集再统计

l    SELECT (SELECT … FROM) FROM


A


1

=订单.new(订单ID,客户.select(客户ID==订单.客户ID).客户名)

/客户表和订单表都是全局变量

l    CURSOR/FETCH

游标有两种用法,其一是外部JAVA程序调用集算器,集算器返回游标,比如下面脚本:


A


1

=订单.select(订单日期>=date("2010-01-01")).cursor()


JAVA获得游标后可继续处理,与JDBC访问游标的方法相同。

其二,在集算器内部使用游标,遍历并完成计算。比如下面脚本:


A

B



1

=订单.cursor()




2

for A1,100

=A2.select(订单日期>=date("2010-01-01"))

 /每次取100条运算


3




 

集算器适合解决复杂业务逻辑的计算,但考虑到简单算法占大多数,而很多程序员习惯使用SQL语句,所以集算器也支持所谓简单SQL”的语法。比如algorithm_1.dfx也可写作:


A

1

$()   select year(订单日期) AS 年份,month(订单日期) AS 月份,count(1) AS 订单数量

From   {订单

where订单.客户ID='VINET'

group   by year(订单日期),month(订单日期)

上述脚本通用于任意SQL$()表示执行默认数据源(集算器)的SQL语句,如果指定数据源名称比如$(orcl),则可以执行相应数据库(数据源名称是orclOracle数据库)的SQL语句。

from {}语句可从任意集算器表达式取数,比如:from {订单.groups(year(订单日期):年份;count(1):订单数量)}

from 也可从文件或excel取数,比如:from d:/emp.xlsx

简单SQL同样支持join…on…语句,但由于SQL语句(指任意RDB)在关联算法上性能较差,因此不建议轻易使用。对于关联运算,集算器有专门的高性能实现方法,后续章节会有介绍。

简单SQL的详情可以参考:http://doc.raqsoft.com.cn/esproc/func/dbquerysql.html#db_sql_

六、        有序引用

SQL基于无序集合做运算,不能直接用序号取数,只能临时生成序号,效率低且用法繁琐。集算器与SQL体系不同,能够基于有序集合运算,可以直接用序号取数。例如:


A


1

=订单.sort(订单日期)

/如果加载时已排序,这步可省略

2

=A1.m(1).订单ID

/第一条

3

=A1.m(-1).订单ID

/最后一条

4

=A1.m(to(3,5))

/3-5

函数m()可按指定序号获取成员,参数为负表示倒序。参数也可以是集合,比如m([3,4,5])。而利用函数to()可按起止序号生成集合,to(3,5)=[3,4,5]

前面例子提到过二分法查询select@b,其实已经利用了集算器有序访问的特点。

 

有时候我们想取前 N名,常规的思路就是先排序,再按位置取前N个成员,集算器脚本如下:

=订单.sort(订单日期).m(to(100))

对应SQL写法如下:

select   top(100) * from 订单 order by 订单日期   --MSSQL

select   * from (select * from 订单 order by 订单日期) where rownum<=100    --Oracle

但上述常规思路要对数据集大排序,运算效率很低。除了常规思路,集算器还有更高效的实现方法:使用函数top

=订单.top(100;订单日期)

函数top只排序出订单日期最早的N条记录,然后中断排序立刻返回,而不是常规思路那样进行全量排序。由于底层模型的限制,SQL不支持这种高性能算法。

 

函数top还可应用于计算列,比如拟对订单采取新的运货费规则,求新规则下运货费最大的前100条订单,而新规则是:如果原运货费大于等于1000,则运货费打八折。

集算器脚本为:

=订单.top(-100;if(运货费>=1000,运货费*0.8,运货费))

 

七、        关联计算

关联计算是关系型数据库的核心算法,在内存计算中应用广泛,比如:统计每年每月的订单数量和订单金额。

该算法对应OracleSQL语句为:

select   to_char(订单.订单日期,'yyyy') AS 年份,to_char(订单.订单日期,'MM') AS 月份,sum(订单明细.单价*订单明细.数量) AS 销售金额,count(1) AS 订单数量

from   订单明细 left join 订单 on 订单明细.订单ID=订单.订单ID

group   by to_char(订单.订单日期,'yyyy'),to_char(订单.订单日期,'MM')

用集算器实现上述算法时,加载数据的脚本不变,业务算法如下(algorithm_2.dfx


A

1

=join(订单明细:子表,订单ID;订单:主表,订单ID)

2

=A1.groups(year(主表.订单日期):年份, month(主表.订单日期):月份; sum(子表.单价*子表.数量):销售金额, count(1):订单数量)

A1:将订单明细与订单关联起来,子表主表为别名,点击单元格可见结果如下

undefined

可以看到,集算器join函数与SQL join语句虽然作用一样,但结构原理大不相同。函数join关联形成的结果,其字段值不是原子数据类型,而是记录,后续可用“.”号表达关系引用,多层关联非常方便。

A2:分组汇总。

计算结果如下:

年份

月份

销售金额

订单数量

2012

7

28988

57

2012

8

26799

71

2012

9

27201

57

2012

10

37793.7

69

2012

11

49704

66

关联关系分很多类,上述订单和订单明细属于其中一类:主子关联。针对主子关联,只需在加载数据时各自按关联字段排序,业务算法中就可用归并算法来提高性能。例如:

=join@m(订单明细:子表,订单ID;订单:主表,订单ID)

函数join@m表示归并关联,只对同序的两个或多个表有效。

集算器的关联计算与RDB不同,RDR对所有类型的关联关系都采用相同的算法,无法进行有针对性的优化,而集算器采取分而治之的理念,对不同类型的关联关系提供了不同的算法,可进行有针对性的透明优化。

 

除了主子关联,最常用的就是外键关联,常用的外键表(或字典表)有分类、地区、城市、员工、客户等。对于外键关联,集算器也有相应的优化方法,即在数据加载阶段事先建立关联,如此一来业务算法就不必临时关联,性能因此提高,并发时效果尤为明显。另外,集算器用指针建立外键关联,访问速度更快。

比如这个案例:订单表的客户ID字段是外键,对应客户表(客户ID、客户名称、地区、城市),需要统计出每个地区每个城市的订单数量。

数据加载脚本(initData_3.dfx)如下:


A

1

=connect("orcl")

2

=A1.query("select   订单ID,客户ID,订单日期,运货费 from 订单").keys(订单ID)

3

=A1.query@x(“select   客户ID,地区,城市 from 客户”).keys(客户ID)

4

=A2.switch(客户ID,A3:客户ID)

5

=env(订单,A2)

6

=env(客户,A3)

A4:用函数switch建立外键关联,将订单表的客户ID字段,替换为客户表相应记录的指针。

业务算法脚本如下(algorithm_3.dfx)如下


A

1

=订单.groups(客户ID.地区:地区 ,客户ID.城市:城市;count(1):订单数量)

加载数据时已经建立了外键指针关联,所以A1中的客户ID”表示:订单表的客户ID字段所指向的客户表记录,客户ID.地区即客户表的地区字段。

脚本中多处使用“.”号表达关联引用,语法比SQL直观易懂,遇到多表多层关联时尤为便捷。而在SQL中,关联一多如同天书。

       上述计算结果如下:

地区

城市

订单数量

东北

大连

40

华东

南京

89

华东

南昌

15

华东

常州

35

华东

温州

18

 

 

 

 

 

八、        内外混合计算

内存计算虽然快,但是内存有限,因此通常只驻留最常用、并发访问最多的数据,而内存放不下或访问频率低的数据,还是要留在硬盘,用到的时候再临时加载,并与内存数据共同参与计算。这就是所谓的内外混合计算。

下面举例说明集算器中的内外混合计算。

案例描述:某零售行业系统中,订单明细访问频率较低,数据量较大,没必要也没办法常驻内存。现在要将订单明细与内存里的订单关联起来,统计出每年每种产品的销售数量。

数据加载脚本(initData_4.dfx)如下:


A

1

=connect("orcl")

2

=A1.query@x("select   订单ID,客户ID,订单日期,运货费 from 订单 order by 订单ID").keys(订单ID)

4

=env(订单,A2)

业务算法脚本(algorithm_4.dfx)如下:


A

1

=connect("orcl")

2

=A1.cursor@x("select   订单ID,产品ID,数量 from 订单明细order by 订单ID")

3

=订单.cursor()

4

=joinx(A2:子表,订单ID; A3:主表,订单ID)

5

=A4.groups(year(主表.订单日期):年份,子表.产品ID:产品 ;sum(子表.数量):销售数量)

A2:执行SQL,以游标方式取订单明细,以便计算远超内存的大量数据。

A3:将订单表转为游标模式,下一步会用到。

A4:关联订单明细表和订单表。函数joinxjoin@m作用类似,都可对有序数据进行归并关联,区别在于前者对游标有效,后者对序表有效。

A5:执行分组汇总。

 

九、        数据更新

数据库中的物理表总会变化,这种变化应当及时反映到共享的内存表中,才能保证内存计算结果的正确,这种情况下就需要更新内存。如果物理表较小,那么解决起来很容易,只要定时执行初始化数据脚本(initData.dfx)就可以了。但如果物理表太大,就不能这样做了,因为初始化脚本会进行全量加载,本身就会消耗大量时间,而且加载时无法进行内存计算。例如:某零售巨头订单数据量较大,从数据库全量加载到内存通常超过5分钟,但为保证一定的实时性,内存数据又需要5分钟更新一次,显然,两者存在明显的矛盾。

解决思路其实很自然,物理表太大的时候,应该进行增量更新,5分钟的增量业务数据通常很小,增量不会影响更新内存的效率。

要实现增量更新,就需要知道哪些是增量数据,不外乎以下三种方法:

方法A:在原表加标记字段以识别。缺点是会改动原表。

方法B:在原库创建一张变更表,将变更的数据记录在内。好处是不动原表,缺点是仍然要动数据库。

方法C:将变更表记录在另一个数据库,或文本文件Excel中。好处是对原数据库不做任何改动,缺点是增加了维护工作量。

集算器支持多数据源计算,所以方法BC没本质区别,下面就以B为例更新订单表。

 

第一步,在数据库中建立订单变更表,继承原表字段,新加一个变更标记字段,当用户修改原始表时,需要在变更表同步记录。如下所示的订单变更表,表示新增1条修改2条删除1条。

订单ID(key)

客户ID

订单日期

运货费

变更标记

10247

VICTE

2012-07-08

101

新增

10248

VINET

2012-07-04

102

修改

10249

TOMSP

2012-07-05

103

修改

10250

HANAR

2012-07-08

104

删除

 

第二步,编写集算器脚本updatemem_4.dfx,进行数据更新。


A

B

1

=connect("orcl")


2

=订单cp=订单.derive()


3

=A1.query("select 订单ID,客户ID,订购日期 订单日期,运货费,变更标记 from 订单变更")


4

=订单删除=A3.select(变更标记=="删除")

=订单cp.select(订单删除.(订单ID).contain(订单ID))

5


=订单cp.delete(B4)

6

=订单新增=A3.select(变更标记=="新增")

=订单cp.insert@f(0:订单新增)

7

=订单修改=A3.select(变更标记=="修改")

=订单cp.select(订单修改.(订单ID).pos(订单ID))

8


=订单cp.delete(B7)

9


=订单cp.insert@f(0:订单修改)

10

=env(订单,订单cp)


11

=A1.execute("delete from 订单变更")


12

=A1.close()


A1:建立数据库连接。

A2:将内存中的订单复制一份,命名为订单cp。下面过程只针对订单cp进行修改,修改完毕再替代内存中的订单,期间订单仍可正常进行业务计算。

A3:取数据库订单变更表。

A4-B5:取出订单变更表中需删除的记录,在订单cp中找到这些记录,并删除。

A6-B6:取出订单变更表中需新增的记录,在订单cp中追加。

A7-B9:这一步是修改订单cp,相当于先删除再追加。也可用modify函数实现修改。

A10:将修改后的订单cp常驻内存,命名为订单。

A11-A12:清空变更表,以便下次取新的变更记录。

上述脚本实现了完整的数据更新,而实际上很多情况下只需要追加数据,这样脚本还会简单很多。

       脚本编写完成后,还需第三步:定时5分钟执行该脚本。   

       定时执行的方法有很多。如果集算器部署为独立服务,与Web应用没有共用JVM,那么可以使用操作系统自带的定时工具(计划任务或crontab),使其定时执行集算器命令(esprocx.exeesprocx.sh)

有些web应用有自己的定时任务管理工具,可定时执行某个JAVA类,这时可以编写JAVA类,用JDBC调用集算器脚本。

       如果web应用没有定时任务管理工具,那就需要手工实现定时任务,即编写JAVA类,继承java内置的定时类TimerTask,在其中调用集算器脚本,再在启动类中调用定时任务类。

       其中启动类myServle4为:

1.     import java.io.IOException;      

2.     import java.util.Timer;      

3.     import javax.servlet.RequestDispatcher;      

4.     import javax.servlet.ServletContext;      

5.     import javax.servlet.ServletException;      

6.     import javax.servlet.http.HttpServlet;      

7.     import javax.servlet.http.HttpServletRequest;      

8.     import javax.servlet.http.HttpServletResponse;      

9.     import org.apache.commons.lang.StringUtils;      

10.   public class myServlet4 extends HttpServlet {      

11.       private static final long serialVersionUID = 1L;      

12.       private Timer timer1 = null;      

13.       private Task task1;                

14.       public ConvergeDataServlet() {      

15.           super();      

16.       }      

17.       public void destroy() {      

18.           super.destroy();       

19.           if(timer1!=null){      

20.               timer1.cancel();      

21.           }      

22.       }      

23.       public void doGet(HttpServletRequest request, HttpServletResponse response)      

24.               throws ServletException, IOException {      

25.       }      

26.       public void doPost(HttpServletRequest request, HttpServletResponse response)      

27.               throws ServletException, IOException {      

28.           doGet(request, response);             

29.       }      

30.       public void init() throws ServletException {      

31.           ServletContext context = getServletContext();      

32.           // 定时刷新时间(5分钟)      

33.           Long delay = new Long(5);      

34.           // 启动定时器      

35.           timer1 = new Timer(true);      

36.           task1 = new Task(context);      

37.           timer1.schedule(task1, delay * 60 * 1000, delay * 60 * 1000);      

38.       }      

39.  

定时任务类Task为:

11.  import java.util.TimerTask;      

12.  import javax.servlet.ServletContext;  

13.   import java.sql.*;

14.   import com.esproc.jdbc.*;    

15.  public class Task extends TimerTask{      

16.      private ServletContext context;      

17.      private static boolean isRunning = true;      

18.      public Task(ServletContext context){      

19.          this.context = context;      

20.      }      

21.      @Override     

22.      public void run() {      

23.          if(!isRunning){      

24.                com.esproc.jdbc.InternalConnection con=null;

25.                try {

26.                      Class.forName("com.esproc.jdbc.InternalDriver");

27.                      con =(com.esproc.jdbc.InternalConnection)DriverManager.getConnection("jdbc:esproc:local://");

28.                      ResultSet rs = con.executeQuery("call updatemem_4()");

29.                }

30.                catch (SQLException e){

31.                      out.println(e);

32.                }finally{

33.                    //关闭数据集

34.                          if (con!=null) con.close();

35.                }

36.          }      

37.      }      

38.  }      

十、        综合示例

下面,通过一个综合示例来看一下在数据源多样、算法复杂的情况下,集算器如何很好地实现内存计算:

案例描述:某B2C网站需要试算订单的邮寄总费用,以便在一定成本下挑选合适的邮费规则。大部分情况下,邮费由包裹的总重量决定,但当订单的价格超过指定值时(比如300美元),则提供免费付运。结果需输出各订单邮寄费用以及总费用。

其中订单表已加载到内存,如下:

Id

cost

weight

Josh1

150

6

Drake

100

3

Megan

100

1

Josh2

200

3

Josh3

500

1

邮费规则每次试算时都不同,因此由参数“pRule”临时传入,格式为json字符串,某次规则如下:

[{"field":"cost","minVal":300,"maxVal":1000000,"Charge":0},

{"field":"weight","minVal":0,"maxVal":1,"Charge":10},

{"field":"weight","minVal":1,"maxVal":5,"Charge":20},

{"field":"weight","minVal":5,"maxVal":10,"Charge":25},

{"field":"weight","minVal":10,"maxVal":1000000,"Charge":40}]

上述json串表示各字段在各种取值范围内时的邮费。第一条记录表示,cost字段取值在3001000000之间的时候,邮费为0(免费付运);第二条记录表示,weight字段取值在01kg)之间时,邮费为10(美元)。

思路:将json串转为二维表,分别找出filed字段为costweight的记录,再对整个订单表进行循环。循环中先判断订单记录中的cost值是否满足免费标准,不满足则根据重量判断邮费档次,之后计算邮费。算完各订单邮费后再计算总邮费,并将汇总结果附加为订单表的最后一条记录。

数据加载过程很简单,这里不再赘述,即:读数据库表,并命名为订单表

业务算法相对复杂,具体如下:


A

B

C

D

1

= pRule.export@j()

/解析json,转二维表



2

=免费=A1.select(field=="cost")

/取免费标准,单条



3

=收费=A1.select(field=="weight").sort(-minVal)

/取收费阶梯,多条



4

=订单表.derive(postage)

/复制并新增字段



5

for A4

if 免费.minVal < A5.cost

>A5. postage= 免费.Charge


6



next


7


for 收费

if A5.weight > B7.minVal

>A5.postage=B7.Charge

8




next A5

9

=A4.record(["sum",,,A4.sum(postage)])




A1:解析json,将其转为二维表。集算器支持多数据源,不仅支持RDB,也支持NOSQL、文件、webService

A2-A3:查询邮费规则,分为免费和收费两种。

A4:新增空字段postage

A5-D8:按两种规则循环订单表,计算相应的邮费,并填入postage字段。这里多处用到流程控制,集算器用缩进表示,其中A5B7为循环语句,C6D8跳入下一轮循环,B5C7为判断语句

A9:在订单表追加新纪录,填入汇总值。

计算结果如下:

Id

cost

weight

postage

Josh1

150

6

25

Drake

100

3

20

Megan

100

1

10

Josh2

200

3

20

Josh3

500

1

0

sum



75

 

       至此,本文详细介绍了集算器用作内存计算引擎的完整过程,同时包括了常用计算方法和高级运算技巧。可以看到,集算器具有以下显著优点:

l   结构简单实施方便,可快速实现内存计算;

l   支持多种调用接口,应用集成没有障碍;

l   支持透明优化,可显著提升计算性能;

l   支持多种数据源,便于实现混合计算;

l   语法敏捷精妙,可轻松实现复杂业务逻辑。

       关于内存计算,还有个多机分布式计算的话题,将在后续文章中进行介绍。

 


以下是广告时间

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



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