Esper学习之八：EPL语法（四）

关于EPL，已经写了三篇了，预估计了一下，除了今天这篇，后面还有5篇左右。大家可别嫌多，官方的文档对EPL的讲解有将近140页，我已经尽量将废话都干掉了，再配合我附上的例子，看我的10篇文章比那140页英文文档肯定舒服多了吧。也请各位原谅我一周一篇的速度，毕竟我还要学习，生活，工作，一个都不能少。

今天讲解的内容包括三块：Order by，Limit，Insert into。大家会SQL的应该很熟悉这三个东西，前两个比较简单，Insert into会有一些差别，篇幅也相对多些。

1.Order by

EPL的Order by和SQL的几乎一模一样，作用都是对输出结果进行排序，但是也有一些需要注意的地方。语法如下：

1. order by expression [asc | desc] [, expression [asc | desc]] [, ...]

expreession表示要排序的字段，asc表示升序排列（从小到大），desc表示降序排列（从大到小）。举个例子：

1. // 每进入5个事件输出一次，并且先按照name升序排列，再按照age降序排列。
2. select * from User output every 5 events order by name, age desc

使用方法很简单，除了和SQL相似的特点外，还有他自己需要注意的几点：

a. 如果不特别说明是升序还是降序，默认情况下按照升序排列。

b. 如果order by的子句中出现了聚合函数，那么该聚合函数必须出现在select的子句中。

c. 出现在select中的expression或者在select中定义的expression，在order by中也有效。

d. 如果order by所在的句子没有join或者没有group by，则排序结果幂等，否则为非幂等。

2. Limit

Limit在EPL中和在SQL中也基本一样，不过SQL中是用具体的数字来表示限制范围，而EPL可以是常量或者变量来表示限制范围。语法如下：

1. limit row_count [offset offset_count]

row_count表示输出多少行，可以是一个整型常量，也可以是一个整型变量，以方便运行时修改。

offset_count表示在当前结果集中跳过n行然后再输出，同样也可以是一个整型变量。如果不使用此参数，则表示跳过0行，即从第一行输出。举例如下：

1. // 输出结果集的第3行到第10行
2. select uri, count(*) from WebEvent group by uri output snapshot every 1 minute order by count(*) desc limit 8 offset 2

除了以上的语法，limit还有一种简化的写法，实际上是参照SQL的标准。

1. limit offset_count[, row_count]

两个参数的含义和上面的一样，并且我们将上面的例子改写一下：

1. // 输出结果集的第3行到第10行
2. select uri, count(*) from WebEvent group by uri output snapshot every 1 minute order by count(*) desc limit 2, 8

如果这个两个参数是负数会怎么样呢？

row_count为负数，则无限制输出，若为0，则不输出。当row_count是变量表示并且变量为null，则无限制输出。

offset _count是不允许负数的，如果是变量表示，并且变量值为null或者负数，则EPL会把他假设为0。

3. Insert into

3.1 简单用法

EPL的Insert into和SQL的有比较大的区别。SQL是往一张表里插入数据，而EPL是把一个事件流的计算结果放入另一个事件流，然后可以对这个事件流进行别的计算。所以Insert into的一个好处就是可以将是事件流的计算结果不断级联，对于那种需要将上一个业务的结果数据放到下一个业务处理的场景再适合不过了。除此之外，Insert into还有合并多个计算结果的作用。到这里相信大家已经对他越来越好奇了，不急，咱们先来看看语法：

1. insert [istream | irstream | rstream] into event_stream_name [ (property_name [, property_name] ) ]

event_stream_name定义了事件流的名称，在执行完insert的定义之后，我们可以使用select对这个事件流进行别的计算。

istream | irstream | rstream表示该事件流允许另一个事件的输入/输入和输出/输出数据能够进入（解释好像很绕。。一会儿看例子就能明白了）

property_name表示该事件流里包含的属性名称，多个属性名之间用逗号分割，并且用小括号括起来。

上面的说明可能不是很好理解，咱们先看个例子：

1. // 将新进入的Asus事件传递到Computer，且Asus的id，size和Computer的cid，csize对应
2. insert into Computer(cid,csize) select id,size from Asus
3. // 第二种写法
4. insert into Computer select id as cid, size as csize Asus

从例子中可以看到，insert into需要配合select进行使用，以表明前一个事件流有哪些计算结果将进入insert into定义的事件流。并且在select中的字段要和insert里的事件流的属性要对应（这里指的对应是数据类型对应，而且属性数量也必须一样）。如果说insert定义的事件流名称在之前已经定义过（insert into中定义的除外），重名是不允许的。

我个人推荐第二种写法，通过as设置的别名即为insert定义的事件流的属性，这样可以避免属性的个数不一致的错误。

刚才说了istream | irstream | rstream的用法，可能有点表述不清楚，这里看一个完整的例子。

1. /**
2. *
3. * @author luonanqin
4. *
5. */
6. class Asus
7. {
8. private int id;
9. private int size;
10. public int getId()
11. {
12. return id;
13. }
14. public void setId(int id)
15. {
16. this.id = id;
17. }
18. public int getSize()
19. {
20. return size;
21. }
22. public void setSize(int size)
23. {
24. this.size = size;
25. }
26. public String toString()
27. {
28. return "id: " + id + ", size: " + size;
29. }
30. }
31. class InsertRstreamListener implements UpdateListener
32. {
33. public void update(EventBean[] newEvents, EventBean[] oldEvents)
34. {
35. if (newEvents != null)
36. {
37. for (int i = 0; i < newEvents.length; i++)
38. {
39. Object id = newEvents[i].get("cid");
40. System.out.println("Insert Asus: cid: " + id);
41. }
42. }
43. if (oldEvents != null)
44. {
45. for (int i = 0; i < oldEvents.length; i++)
46. {
47. Object id = oldEvents[i].get("cid");
48. System.out.println("Remove Asus: cid: " + id);
49. }
50. }
51. System.out.println();
52. }
53. }
54. public class InsertRstreamTest {
55. public static void main(String[] args) throws InterruptedException {
56. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
57. EPAdministrator admin = epService.getEPAdministrator();
58. String asus = Asus.class.getName();
59. String insertEPL = "insert rstream into Computer(cid,csize) select id,size from " + asus + ".win:length(1)";
60. String insertSelectEPL = "select cid from Computer.win:length_batch(2)";
61. EPStatement state = admin.createEPL(insertEPL);
62. EPStatement state1 = admin.createEPL(insertSelectEPL);
63. state1.addListener(new InsertRstreamListener());
64. EPRuntime runtime = epService.getEPRuntime();
65. Asus apple1 = new Asus();
66. apple1.setId(1);
67. apple1.setSize(1);
68. System.out.println("Send Asus: " + apple1);
69. runtime.sendEvent(apple1);
70. Asus apple2 = new Asus();
71. apple2.setId(2);
72. apple2.setSize(1);
73. System.out.println("Send Asus: " + apple2);
74. runtime.sendEvent(apple2);
75. Asus apple3 = new Asus();
76. apple3.setId(3);
77. apple3.setSize(3);
78. System.out.println("Send Asus: " + apple3);
79. runtime.sendEvent(apple3);
80. Asus apple4 = new Asus();
81. apple4.setId(4);
82. apple4.setSize(4);
83. System.out.println("Send Asus: " + apple4);
84. runtime.sendEvent(apple4);
85. Asus apple5 = new Asus();
86. apple5.setId(5);
87. apple5.setSize(3);
88. System.out.println("Send Asus: " + apple5);
89. runtime.sendEvent(apple5);
90. Asus apple6 = new Asus();
91. apple6.setId(6);
92. apple6.setSize(4);
93. System.out.println("Send Asus: " + apple6);
94. runtime.sendEvent(apple6);
95. }
96. }

执行结果：

1. Send Asus: id: 1, size: 1
2. Send Asus: id: 2, size: 1
3. Send Asus: id: 3, size: 3
4. Insert Asus: cid: 1
5. Insert Asus: cid: 2
6. Send Asus: id: 4, size: 4
7. Send Asus: id: 5, size: 3
8. Insert Asus: cid: 3
9. Insert Asus: cid: 4
10. Send Asus: id: 6, size: 4

这个例子中，insertEPL表示当Asus事件从length为1的view中移除时，把移除的事件放入Computer。insertSelectEPL是对Computer的事件流进行计算，这里只是在每进入两个事件时才输出这两个事件的cid。而rstream在这里的表现，从执行结果中可以看到，在进入id为1 2 3的事件后，insertSelectEPL的监听器被触发，因为id为1和2的事件是在发送了Asus的id为2和3的事件之后被移除了，之后就进入了Computer，并满足了length=2，因此在监听器里看到有id为1和2的事件进入了Computer。

如果不显示指定rstream，则insert into只允许istream的事件流进入Computer。如果指定为irstream，那么进入的和移除的Asus都会进入到Computer。

上面的例子都是指定了insert into里事件流会有什么属性，如果不指定会是什么结果呢？请看例句：

1. insert into Computer select * from Asus

很容易想到，这里实际上是把进入引擎的Asus事件都传递到Computer定义的事件流中，并且属性什么的完全和Asus一样，可以说是Asus的一个复制版本，只是名字不一样。也许有人觉得这么做没什么意思，直接计算Asus事件流不就可以了么，实际上在业务处理数据时，这种做法就可以屏蔽掉外部的数据来源，做到业务层上的隔离。

假设Asus中还包含其他的JavaBean，同样也可以将这个Bean的数据传递到另一个事件流中。例句如下：

1. // Lenovo中包含了thinkpad这个JavaBean
2. insert into Computer select thinkpad.* from Lenovo

3.2 Merge Event Stream

insert into除了接收一个流的事件，同时也支持多个流的合并。通俗一点来说，合并的流数据要一致才可以合并。而且在第一次定义insert的事件流以后，别的事件流想要被合并就必须和之前定义的属性数量和数据类型对应。举例如下：

1. // 定义Computer并把Asus的数据输入
2. insert into Computer(cid, csize) select aid,asize from Asus
3. // 根据之前的Computer定义将Lenovo对应的属性输入
4. insert into Computer(cid, csize) select lid,lsize from Lenovo

如果说select了多个事件流，但是你只想输入其中一个，应该像下面这样写：

1. insert into Computer select l.* from Asus as a, Lenovo as l

除此之外，EPL还支持调用函数转换事件后再输入insert into：

1. // 将Lenovo事件转换后输入Computer
2. insert into Computer select Converter.convert(l) from Lenovo as l

注意，使用自定义函数一定要返回javabean，map，或者Object数组，且不能用as来为转换后的结果设置别名。

3.3 Decorated Events

之前所见到的不是将事件流整体输入insert，就是将事件流的部分属性输入insert。实际上可以将事件流整体和事件流属性组成的复杂表达式一起放入insert。示例如下：

1. insert into Computer select *, size*price as sp from Asus
2. // 第一个*表示Asus，size*price的*表示乘法，两者互不影响

如果说别的事件流想进入此insert，那么事件流属性一定要和第一个*表示的所有属性相同。

3.4 Event Objects Instantiated by insert into

前面的所有例子中，对于insert into的事件结构都是在insert子句中配合select子句进行定义的。如果我们想用已经定义好的事件结构是否可以呢？答案是肯定的。但是如果事件是javabean，并且事先没有注册到引擎，则需要insert子句中写上类的全名。例如：

1. insert into test.computer.Computer ...

当然，如果在使用之前有注册过，那么使用注册时的名称也是可以的。

因为事件结构是早就定义好的，所以在写select的时候就必须符合insert事件中的属性了，如果属性名称不一样需要使用as加上别名，一样的可以不用设置别名，且数据类型也要一一对应。例如：

1. // Computer中包含cid和csize属性
2. insert into test.computer.Computer select aid as cid, asize as csize from Dell

但是这种用法在Computer存在包含了参数的构造方法时就显得没那么必须了。先看一个完整例子，你也许就会明白了。

1. /**
2. *
3. * @author luonanqin
4. *
5. */
6. class Car
7. {
8. private int size;
9. private String name;
10. private int price;
11. public void setSize(int size)
12. {
13. this.size = size;
14. }
15. public void setName(String name)
16. {
17. this.name = name;
18. }
19. public void setPrice(int price)
20. {
21. this.price = price;
22. }
23. public int getSize()
24. {
25. return size;
26. }
27. public String getName()
28. {
29. return name;
30. }
31. public int getPrice()
32. {
33. return price;
34. }
35. }
36. class Auto
37. {
38. private int autoSize;
39. private String autoName;
40. public Auto(int s, String n)
41. {
42. this.autoSize = s;
43. this.autoName = n;
44. }
45. public String toString()
46. {
47. return "AutoSize: " + autoSize + ", AutoName: " + autoName;
48. }
49. }
50. class Benz
51. {
52. private int benzSize;
53. private String benzName;
54. public void setBenzSize(int benzSize)
55. {
56. this.benzSize = benzSize;
57. }
58. public void setBenzName(String benzName)
59. {
60. this.benzName = benzName;
61. }
62. public String toString()
63. {
64. return "BenzSize: " + benzSize + ", BenzName: " + benzName;
65. }
66. }
67. class InstantiatePopulateListener implements UpdateListener
68. {
69. public void update(EventBean[] newEvents, EventBean[] oldEvents)
70. {
71. if (newEvents != null)
72. {
73. Object car = newEvents[0].getUnderlying();
74. System.out.println(car);
75. }
76. }
77. }
78. public class InstantiatePopulateTest
79. {
80. public static void main(String[] args) throws InterruptedException
81. {
82. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
83. EPAdministrator admin = epService.getEPAdministrator();
84. String car = Car.class.getName();
85. String auto = Auto.class.getName();
86. String benz = Benz.class.getName();
87. String cartToAutoEpl = "insert into " + auto + " select size, name from " + car;
88. String autoEpl = "select * from " + auto;
89. String cartToBenzEpl = "insert into " + benz + " select size as benzSize, name as benzName from " + car;
90. // String benzEpl2 = "insert into " + benz + "(benzSize,benzName) select size, name from " + car;<pre name="code" class="java">     String benzEpl = "select * from " + benz;</pre>admin.createEPL(cartToAutoEpl);EPStatement state1 = admin.createEPL(autoEpl);state1.addListener(new InstantiatePopulateListener());admin.createEPL(cartToBenzEpl);EPStatement state2 = admin.createEPL(benzEpl);state2.addListener(new InstantiatePopulateListener());EPRuntime runtime = epService.getEPRuntime();Car c1 = new Car();c1.setSize(1);c1.setName("car1");c1.setPrice(11);runtime.sendEvent(c1);Car c2 = new Car();c2.setSize(2);c2.setName("car2");c2.setPrice(22);runtime.sendEvent(c2);}}

执行结果：

1. AutoSize: 1, AutoName: car1
2. BenzSize: 1, BenzName: car1
3. AutoSize: 2, AutoName: car2
4. BenzSize: 2, BenzName: car2

这里的执行结果很容易理解，关键是carToAutoEpl和carToBenzEpl两个句子。

对于Auto的JavaBean，我们可以发现它包含一个有参数的构造函数且没有属性对应的set方法，在carToAutoEpl中，select的内容并没有和属性名称对应起来。这种写法确实是正确的，正因为Auto中定了含参的构造函数，才使得select可以写的更随意。但是一定要记住，构造函数里的参数顺序一定要和select中的属性的数据类型对应起来，如果这里把name和size互换位置，必定报错！

对于Benz的JavaBean，可以看到每个属性都有对应的set方法，而没有含参的构造函数，所以select中属性的名称需要as来设置别名。当然，像benzEpl2那种写法，同样可以避免select中设置别名。

一句话总结，如果JavaBean中有含参的构造函数，EPL中不需要显示写出属性名称。如果没有构造函数，那么必须包含set方法，且select中要写出具体的属性。这几种写法各有各的好处，大家使用时可针对具体的情况选择性使用。