Java 嵌入数据处理引擎：SQLite 的挑战者 esProc SPL

痛定思痛。 2023-09-29 17:24 14阅读 0赞

很多免费开源数据处理引擎都可以嵌入Java应用中，其中SQLite历史悠久、用户众多；后起之秀esProc SPL功能也较强，下面对两者进行多方面的比较。

### 基本特征 ###

**语言风格**

SQLite使用传统的SQL代码（两者在本文等价），SQL在业界很流行，不必更多介绍。SPL是现代的数据计算语言，属于简化的面向对象的语言风格，有对象的概念，可以用点号访问属性并进行多步骤计算，但没有继承重载这些内容，不算彻底的面向对象语言。

**运行模式**

SQLite是用C语言开发的跨平台小型数据库，可嵌入其他开发语言，也可在单机执行。SPL是用Java开发的跨平台的数据计算语言，可嵌入Java，可在单机执行，可以数据计算服务的形式被远程调用。两者的代码都是解释执行的。

**IDE**

SQLite官方只提供了命令行工具，图形化工具要由第三方提供，但由于SQL的特性，这些工具大都没有断点调试、变量观察等基本的IDE功能。SPL提供了图形化IDE，包括完整的调试功能、表格形式的变量观察功能。

**学习难度**

SQL历史悠久资料丰富，入门学习时难度较低，但复杂运算时难度很大。而且，SQL缺乏流程处理能力（分支结构和循环结构），要借助Java的相关功能才能实现完整的业务逻辑，所以通常还要学习Java。

SPL的目标是简化Java和SQL的编码，刻意简化了许多概念，学习难度较低。SPL兼具结构化数据计算能力和流程处理能力，可以实现完整的业务逻辑，不必借助其他语言。

**代码量**

SQL进行简单计算时代码量很低，如果遇到较复杂计算，代码量会急剧增长。SQL经常要用Java配合实现完整的业务逻辑，Java的流程处理功能没有为结构化数据对象做优化，代码通常较繁琐。

SPL是现代计算语言，避免了SQL的诸多弱点，无论简单还是复杂计算，代码量都很低。SPL的流程处理功能为结构化数据对象做了优化，相关代码更加简单。

### 数据源读取 ###

**自有数据格式**

SQLite有自有（私有）数据格式，即库文件，一个库文件包含多个表。可以用命令行命令或API（JDBC URL）创建库文件，但不能用SQL代码直接创建库文件。比如，用Java新建一个SQLite库文件，如果已存在则打开库文件

Class.forName("org.sqlite.JDBC");
    Connection conn = DriverManager.getConnection("jdbc:sqlite: d:/ex1.db");

SPL有两种自有数据格式，其中一种是组表文件，专用于大数据高性能计算，不是本文重点；另一种是集文件，专用于中小数据量和嵌入式计算。SPL不需要建库，也没有库的概念，每个集文件对应一个表。

**外部数据源**

SQLite只支持文本数据文件，包括TAB分隔的txt、逗号分隔的csv，也可自定义其它分隔符。

SPL支持多种数据源，包括：

*  JDBC（即所有的RDB）
 *  csv、TXT、JSON、XML、Excel
 *  HBase、HDFS、Hive、Spark
 *  Restful、WebService、Webcrawl
 *  Elasticsearch、MongoDB、Kafka、R2dbc、FTP
 *  Cassandra、DynamoDB、influxDB、Redis、SAP

这些数据源都可以直接使用，非常方便。对于其他未列入的数据源，SPL也提供了接口规范，只要按规范输出为SPL的结构化数据对象，就可以进行后续计算。

**访问自有数据格式**

SQLite通过SQL访问库文件中的表，生成SQL结果集，即内存中的结构化数据对象。读取表时一般伴随着查询：

select * from Orders where Amount>2000 and Amount<=3000

SPL通过SPL的T函数或import函数读取集文件，生成序表（相当于SQL结果集）。等价的代码：

T("d:/Orders.btx").select(Amount>2000 && Amount<=3000)

**读取csv文件**

SQLite读取csv文件需要三步，第一步：进入管理命令行。

#在Windows命令行，打开或新建名为dbname的数据库
    sqlite3.exe new.db

第二步，在管理命令行新建库表，并导入数据：

#当字段类型都是字符串时，不必手工建表。
    create table Orders(
    OrderID int,
    Client varchar(100),
    SellerID int,
    Amount float,
    OrderDate date
    );
    .import --csv d:/Orders.csv Orders

第三步，在Java代码中嵌入SQL查询代码：

select * from Orders where Amount>2000 and Amount<=3000

上面的方法需要人工参与，比较繁琐。也可以全部用Java代码实现，第一步，先在操作系统建立一个文本文件（比如importOrders.txt），内容即上面第二步。

第二步，在Java代码调用操作系统命令行，即用Runtime.getRuntime().exec(…)执行命令：

sqlite3.exe dbname.db < importOrders.txt

第三步不变。

这种方法需要额外的操作系统执行权限，安全风险比较大。如果想降低安全风险，就要用循环语句执行SQL一条条插入记录，代码冗长，修改麻烦。

SPL读取csv文件，只需一步，在Java里嵌入下面的SPL代码：

T("d:/Orders.csv").select(Amount>2000 && Amount<=3000)

函数T不仅可以读取集文件，也可以读取csv文件，并生成序表。序表是SPL的结构化数据对象，可类比为SQL结果集。SPL导入数据时，数据类型会自动解析，不必手工指定。整个过程无需人工参与，权限要求低，代码简短，比SQLite方便多了。

如果csv格式不规范，还可以使用import函数指定分隔符、字段类型、跳过行数，并处理转义符、引号、括号等，比SQLite提供的功能丰富多了。

对于csv之外的数据源，SQLite都没有提供方便的导入方法，取数过程非常繁琐，而SPL支持多种数据源，取数过程简单方便，可以显著提高开发效率。

**读取多层结构数据**

Json和XML是常用的多层结构数据。SQLite架构简单，又有Json计算能力，有时会承担Json文件/RESTful的计算功能，但SQLite不能直接解析Json文件/RESTful，需要用Java代码硬写，或借助第三方类库，最后再拼成insert语句插入数据表，代码非常繁琐，这里就不展示了。

SPL架构同样简单，且可以直接解析Json文件/RESTful，可以大幅简化代码，比如：

json(file("d:/xml/emp_orders.json").read()).select(Amount>2000 && Amount<=3000)
    json(httpfile("http://127.0.0.1:6868/api/orders").read()).select(Amount>2000 && Amount<=3000)

SQLite没有XML计算能力，也不能直接解析XML文件/WebService，只能借助外部Java代码解析计算，非常繁琐。  
SPL可以直接读取XML文件：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=file("d:/xml/emp_orders.xml").read()</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=xml(A1,"xml/row")</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>=A2.select(Amount&gt;1000 &amp;&amp; Amount&lt;=2000 &amp;&amp; like@c(Client,"*business*"))</td> 
  </tr> 
 </tbody> 
</table>

也可以方便地读取WebService：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=ws_client("http://127.0.0.1:6868/ws/RQWebService.asmx?wsdl")</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=ws_call(A1,"RQWebService":"RQWebServiceSoap":"getEmp_orders")</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>=A2.select(Amount&gt;1000 &amp;&amp; Amount&lt;=2000 &amp;&amp; like@c(Client,"*business*"))</td> 
  </tr> 
 </tbody> 
</table>

SPL序表支持多层结构数据，比SQL库表的二维结构更容易表达Json/XML，计算代码也更简单。这部分内容不是本文重点，就此略过。

**跨源计算**

SQLite的外部数据源只支持csv文件，跨源计算就是csv文件和库表间的关联、交集、子查询等计算。SQL是封闭的计算语言，不能直接计算库外数据，需要经过一个入库的过程，把csv文件变成库表之后才能进行跨源计算。参考前面的代码可知，入库的过程比较麻烦，不能只用SQL，还要借助Java或命令行。

SPL开放性较好，可以直接计算多种数据源，数据源之间可以方便地进行跨源计算。比如csv和RESTful左关联：

=join@1(json(httpfile("http://127.0.0.1:6868/api/orders").read()):o,SellerId; T("d:/Emp.csv"):e,EId)

写成多步骤的形式更易读：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=Orders=json(httpfile("http://127.0.0.1:6868/api/orders").read())</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=Employees=T("d:/Emp.csv")</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>=join@1(Orders:o,SellerId;Employees:e,EId)</td> 
  </tr> 
 </tbody> 
</table>

只用SPL语言就可以实现跨源计算，不必借助Java或命令行，代码简短易懂，比SQL的开发效率高得多。

![在这里插入图片描述][a185d51f9b67408ab0fea07a7c5625f1.jpeg_pic_center]

### 数据计算 ###

**基础计算**

SQLite支持常见的基础计算：

#选出部分字段
    select Client,Amount from Orders
    #模糊查询
    select * from Orders where Amount>1000 and Client like '%s%'
    #排序
    select * from Orders order by Client, Amount desc
    #去重
    select distinct Client from Orders
    #分组汇总
    select strftime('%Y',OrderDate) as y, Client, sum(Amount) as amt from Orders group by strftime('%Y',OrderDate), Client having amt>3000
    #并集
    select * from Orders9 where Amount>3000 
    union 
    select * from Orders9 where strftime('%Y',OrderDate)='2009';
    #子查询
    select * from (select strftime('%Y',OrderDate) as y, Client, sum(Amount) as amt from Orders group by strftime('%Y',OrderDate), Client) where  Client like '%s%';

SPL实现常见的基础计算：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
   <td>B</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=Orders.new(Client,Amount)</td> 
   <td>//选出部分字段</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=Orders.select(Amount&gt;1000 &amp;&amp; like(Client,\"*s*\"))</td> 
   <td>//模糊查询</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>= Orders.sort(Client,-Amount)</td> 
   <td>//排序</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>= Orders.id(Client)</td> 
   <td>//去重</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>=Orders.groups(year(OrderDate):y,Client;sum(Amount):amt).select(amt&gt;3000)</td> 
   <td>//分组汇总</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>=[Orders.select(Amount&gt;3000),A1.select(year(OrderDate)==2009)].union()</td> 
   <td>//并集</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>=Orders.groups(year(OrderDate):y,Client;sum(Amount):amt).select(like(Client,\"*s*\"))</td> 
   <td>//子查询</td> 
  </tr> 
 </tbody> 
</table>

SQLite和SPL都有丰富的函数进行基础计算，学习掌握都不难。

**综合计算**

先看简单些的，计算TopN，SQLite：

select * from Orders order by Amount limit 3

SQLite代码简短，但因为不支持top函数，也不支持序号伪列（比如Oracle的rownum），只能改用limit实现，理解起来不够直观。

SPL实现TopN：

Orders.top(3;Amount)

SPL支持真正的行号，也支持top函数，代码更短，且易于理解。

组内TopN，SQLite：

select * from (select *, row_number() over (partition by Client order by Amount) as row_number from Orders) where row_number<=3

SQL代码略显复杂，主要因为SQLite不支持top函数，而limit函数只能限制总记录数，不能限制各组记录数，这种情况下必须用组内行号。SQLite没有真正的行号字段，要用窗口函数生成伪列再用，代码自然复杂。事实上，缺乏行号并非SQLite自身的问题，而是整个SQL体系的问题，其他数据库也没有行号。

SPL实现组内TopN：

Orders.group(Client).(~.top(3;Amount)).conj()

SPL代码简单多了，而且很好理解，先按Client分组，再对各组（即符号~）计算TopN，最后合并各组的计算结果。SPL之所以代码简单，表面上是因为直接支持Top函数，本质是因为SPL有真正的行号字段，或者说，SPL支持有序集合。SPL代码简单，还因为集合化更加彻底，可以实现真正的分组，即只分组不汇总，这就可以直观地计算组内数据。SQL集合化不彻底，分组时必须汇总，不能直观地计算组内数据，只能借助窗口函数。

再看复杂些的计算，某支股票的最大连续上涨天数，SQLite：

select max(continuousdays)
    from (
    select count(*) continuousdays
    from (
    select sum(risingflag) over (order by day) norisingdays
    from (
    select day, case when price>
    lag(price) over (order by day) then 0 else 1 end risingflag from tbl
    )
    ) group by norisingdays
    )

上面代码冗长复杂。SQL很难直接表达连续上涨的概念，只能换个方法变相实现，即通过累计不涨天数来计算连续上涨天数，这种方法技巧性强，编写难度大且不易理解。而且，SQL难以调试，导致维护困难。

SPL求最大连续上涨天数：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=tbl.sort(day) </td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=t=0,A1.max(t=if(price&gt;price[-1],t+1,0))</td> 
  </tr> 
 </tbody> 
</table>

上面代码简单多了。SPL容易表达连续上涨的概念，先按日期排序；再遍历记录，发现上涨则计数器加1。这里既用到了循环函数max，也用到了有序集合，代码中\[-1\]表示上一条，是相对位置的表示方法，price\[-1\]表示上一个交易日的股价，比整体移行（lag函数）更直观。

找出销售额占到一半的前n个客户，并按销售额从大到小排序。SQLite：

with A as
    (select client,amount,row_number() over (order by amount) ranknumber
    from sales)
    select client,amount
    from (select client,amount,sum(amount) over (order by ranknumber) acc
    from A)
    where acc>(select sum(amount)/2 from sales)
    order by amount des

上面代码复杂。SQL很难处理恰好要过线的客户，只能换个方法变相实现，即计算销售额从小到大的累计值，反过来找出累计值不在后一半的客户。这种方法技巧性强，代码冗长，而且难以调试。  
SPL求销售额占到一半的前n个客户：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
   <td>B</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=sales.sort(amount:-1)</td> 
   <td>/销售额逆序排序，可在SQL中完成</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>=A2.cumulate(amount)</td> 
   <td>/计算累计序列</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>=A3.m(-1)/2</td> 
   <td>/最后的累计即总额</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>=A3.pselect(~&gt;=A4)</td> 
   <td>/超过一半的位置</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>=A2(to(A5))</td> 
   <td>/按位置取值</td> 
  </tr> 
 </tbody> 
</table>

上面代码相对简单。SPL集合化成更彻底，可以用变量方便地表达集合，并在下一步用变量引用集合继续计算，因此特别适合多步骤计算。将大问题分解为多个小步骤，可以方便地实现复杂的计算目标，代码不仅简短，而且易于理解。此外，多步骤计算天然支持调试，无形中提高了开发效率。

从上面例子可以看出，SQL只适合较简单的计算，而SPL支持有序集合，集合化更彻底，从简单到复杂的计算都可以很好的完成。此外，SPL还支持游离记录，可以用点号直观地引用关联表，从而简化复杂的关联计算。

**日期和字符串函数**。SQLite支持日期和字符串函数，比如日期增减、截取字符串等，但还不够丰富，很多常用函数并不直接支持，比如季度增减、工作日计算等。

SPL提供了更丰富的日期和字符串函数，在数量和功能上远远超过了SOLite。比如：

季度增减：elapse@q("2020-02-27",-3)			//返回2019-05-27
    N个工作日之后的日期：workday(date("2022-01-01"),25)	//返回2022-02-04
    判断是否全为数字：isdigit("12345")			//返回true
    取子串前面的字符串：substr@l("abCDcdef","cd")		//返回abCD
    按竖线拆成字符串数组："aa|bb|cc".split("|")		//返回["aa","bb","cc"]

SPL还支持年份增减、求季度、按正则表达式拆分字符串、拆出SQL的where或select部分、拆出单词、按标记拆HTML等大量函数。

**SPL函数选项和层次参数**

值得一提的是，为了进一步提高开发效率，SPL还提供了独特的函数语法。

有大量功能类似的函数时，SQL要用不同的名字或者参数进行区分，使用不太方便。而SPL提供了非常独特的函数选项，使功能相似的函数可以共用一个函数名，只用函数选项区分差别。比如，select函数的基本功能是过滤，如果只过滤出符合条件的第1条记录，可使用选项@1：

T.select@1(Amount>1000)

对有序数据用二分法进行快速过滤，使用@b：

T.select@b(Amount>1000)

函数选项还可以组合搭配，比如：

Orders.select@1b(Amount>1000)

结构化运算函数的参数有些很复杂，SQL需要用各种关键字把一条语句的参数分隔成多个组，但这会动用很多关键字，也使语句结构不统一。SPL使用层次参数简化了复杂参数的表达，即通过分号、逗号、冒号自高而低将参数分为三层：

join(Orders:o,SellerId ; Employees:e,EId)

### 数据持久化 ###

SQLite通过直接处理库表来实现数据持久化，分为增、改、删三种：

insert into Orders values(201,'DSL',10,2000.0,'2019-01-01')
    update Orders set Client='IBM' where orderID=201
    delete from Orders where orderID=201

批量新增是常见的需求，SQLite代码如下：

insert into Orders(OrderID,Client,SellerID,Amount,OrderDate) 
    select 201,'DSL',10,2000.0,'2019-01-01'
    union all
    select 202,'IBM',10,3000.0,'2019-01-01'

SPL集文件的持久化有两种方式。第一种方式：直接处理集文件，可实现记录新增（及批量新增）。比如：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=create(OrderID,Client,SellerID,Amount,OrderDate)</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=A1.record([201,"HDR",9,2100.0,date("2021-01-01"),202,"IBM",9,1900,date("2021-01-02")])</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>=file("d:/Orders.btx").export@ab(A2)</td> 
  </tr> 
 </tbody> 
</table>

第二种方式：先处理内存里的序表，再将序表覆盖写入原来的集文件。这种方式可实现增、改、删。只要将上面A3格里的export@ab改为export@b即可，@a表示追加，@b表示集文件格式。这种方式性能不如SQLite，但嵌入计算的数据量普遍不大，覆写的速度通常可接受。

SPL组表支持高性能增删改，适用于大数据量高性能计算，不是本文重点。

SQLite只支持库表的持久化，不支持其他数据源，包括csv文件，硬要实现的话只能借助Java硬编码或第三方类库，代码非常繁琐。

SPL除了支持集文件的持久化，也支持其他数据源，同样是通过序表为媒介。

file("d:/Orders.csv").export@t(A2)			//csv文件
    file("d:/Orders.xlsx").xlsexport@t(A2)			//xls文件
    file("d:/Orders.json").write(json(A2))			//json文件

特别地，SPL支持任意数据库的持久化。比如：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
   <td>B</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=connect("orcl")</td> 
   <td>/连接外部oracle</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>=T=A1.query("select * from salesR where SellerID=?",10)</td> 
   <td>/批量查询，序表T</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>=NT=T.derive()</td> 
   <td>/复制出新序表NT</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>=NT.field("SELLERID",9)</td> 
   <td>/批量修改新序表</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>=A1.update(NT:T,sales;ORDERID)</td> 
   <td>/持久化</td> 
  </tr> 
 </tbody> 
</table>

数据库的持久化依然以序表为媒介，可以明显看出这种方式的优点：函数update自动比对修改（增改删）前后的序表，可方便地实现批量数据地持久化。

### 流程处理 ###

SQLite缺乏流程处理能力，无法实现完整的业务逻辑，只能将SQL数据对象转为Java的resultSet/List<EntityBean>，再用for/if语句处理流程，最后再转回SQL的数据对象，代码非常繁琐。复杂的业务逻辑要在SQL对象和Java对象之间转换多次，更加麻烦。

SPL提供了流程控制语句，配合内置的结构化数据对象，可以方便地实现各类业务逻辑。

分支结构：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
   <td>B</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>…</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>if T.AMOUNT&gt;10000</td> 
   <td>=T.BONUS=T.AMOUNT*0.05</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>else if T.AMOUNT&gt;=5000 &amp;&amp; T.AMOUNT&lt;10000</td> 
   <td>=T.BONUS=T.AMOUNT*0.03</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>else if T.AMOUNT&gt;=2000 &amp;&amp; T.AMOUNT&lt;5000</td> 
   <td>=T.BONUS=T.AMOUNT*0.02</td> 
  </tr> 
 </tbody> 
</table>

循环结构：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
   <td>B</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>=db=connect("db")</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td colspan="2">=T=db.query@x("select * from sales where SellerID=? order by OrderDate",9)</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>for T</td> 
   <td>=A3.BONUS=A3.BONUS+A3.AMOUNT*0.01</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td></td> 
   <td>=A3.CLIENT=CONCAT(LEFT(A3.CLIENT,4), " co.,ltd.")</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td></td> 
   <td>…</td> 
  </tr> 
 </tbody> 
</table>

上述代码之外，SPL还有更多针对结构化数据的流程处理功能，可进一步提高开发效率，比如：每轮循环取一批而不是一条记录；某字段值变化时循环一轮。

### 应用结构 ###

**Java集成**

SQLite提供了JDBC接口，可以被Java代码方便地集成：

Class.forName("org.sqlite.JDBC");
    Connection conn = DriverManager.getConnection("jdbc:sqlite: d:/ex1.db");
    Statement statement = conn.createStatement();
    ResultSet results = statement.executeQuery("select * from Orders where Amount>1000 and Client like '%s%'");

SQLite的内核是C语言编写的，虽然可以被集成到Java应用中，但不能无缝集成，和Java主程序交换数据时要耗费额外的时间，在数据量较大或交互较频繁时性能就会明显下降。同样因为内核是C程序，SQLite会在一定程度上破坏Java架构的一致性和健壮性。

SPL同样提供了JDBC接口，集成方法和SQLite类似：

Class.forName("com.esproc.jdbc.InternalDriver");
    Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
    Statement statement = conn.createStatement();
    ResultSet result = statement.executeQuery("=T(\"D:/Orders.csv\").select(Amount>1000 && like(Client,\"*s*\"))");

SPL是纯Java编写的，可被Java应用无缝集成，架构一致性强，系统更稳定，不需要耗费额外时间交换数据，性能更有保障。

**业务逻辑外置**

一般的RDB支持存储过程，可将业务逻辑外置于Java程序，但SQLite不支持存储过程，完整的业务逻辑通常要借助Java的流程处理功能才能实现，也就不能外置于Java程序。业务逻辑不能外置于Java代码，导致两者耦合性过高。

SPL可实现完整的业务逻辑，业务逻辑（或复杂的、经常变化的计算代码）可保存为脚本文件，并外置于Java程序。Java程序以存储过程的形式引用脚本文件名：

Class.forName("com.esproc.jdbc.InternalDriver");
    Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
    CallableStatement statement = conn.prepareCall("{call queryOrders()}");
    statement.execute();

外置的SPL脚本不仅可以有效降低系统耦合性，还具有热切换的特点。SPL是解释型代码，修改后不必编译就可直接运行，也不必重启Java应用，可有效降低维护成本。

**内存计算**

SQLite可用于内存计算，一般在应用启动时将数据加载至内存（URL有变化）：

Connection conn= DriverManager.getConnection("jdbc:sqlite:file::memory:?cache=shared");
    Statement st =conn.createStatement();
    st.execute("restore from d:/ex1");

需要进行业务计算时，就可以直接利用之前加载好的内存数据：

Class.forName("org.sqlite.JDBC");
    Connection conn= DriverManager.getConnection("jdbc:sqlite:file::memory:?cache=shared");
    Statement statement = conn.createStatement();
    ResultSet results = statement.executeQuery("select OrderID,Client,Amount,Name,Gender Dept from Orders left join Employees on Orders.SellerId=Empoyees.EId");

SPL同样可用于内存计算，在应用启动时执行脚本，将数据加载至内存（URL不变）：

<table> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>A</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>= connect("orcl").query@x("select OrderID,Client,SellerID,OrderDate,Amount from orders order by OrderID")</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>&gt;env(Orders,A1)</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>&gt;env(Employees,T("d:/Employees.csv"))</td> 
  </tr> 
 </tbody> 
</table>

需要进行业务计算时，可直接利用之前加载好的内存数据：

Class.forName("com.esproc.jdbc.InternalDriver");
    Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
    Statement statement = conn.createStatement();
    ResultSet result = statement.executeQuery("=join@1(Orders:O,SellerId; Employees:E,EId).new(O.OrderID, O.Client,O.Amount,E.Name,E.Gender,E.Dept)");

关联计算如果频繁发生，性能必然下降，改用宽表的话又太占内存，SQL没有好办法解决这个问题。SPL独有预关联技术，可大幅提升关联计算的性能，且不占用额外内存。SPL还有更多内存计算技术，通常比SQLite性能好得多，包括并行计算、指针式复用、内存压缩等。

SQLite可以方便地嵌入Java，但数据源加载繁琐，计算能力不足，无法独立完成业务逻辑，架构上弱点颇多。SPL也很容易嵌入Java，且直接支持更多数据源，计算能力更强，流程处理方便，可独立实现业务逻辑。SPL还提供了多种优化体系结构的手段，代码既可外置也可内置于Java，支持解释执行和热切换，可进行高性能内存计算。

### SPL资料 ###

*  [SPL下载][SPL]
 *  [SPL源代码][SPL 1]

[a185d51f9b67408ab0fea07a7c5625f1.jpeg_pic_center]: https://img-blog.csdnimg.cn/a185d51f9b67408ab0fea07a7c5625f1.jpeg#pic_center
[SPL]: http://c.raqsoft.com.cn/article/1595816810031
[SPL 1]: https://github.com/SPLWare/esProc