Esper学习之十二：EPL语法（八）

今天的内容十分重要，在Esper的应用中是十分常用的功能之一。它是一种事件集合，我们可以对这个集合进行增删查改，所以在复杂的业务场景中我们肯定不会缺少它。它就是Named Window。

由于本篇篇幅较长，希望各位童鞋慢慢阅读，并仔细研究文档中或者我给出的例子。

1.Create Named Window

本篇的开头有说过named window是一种事件集合，它可以存储一种类型或多种类型的事件。如果我们不移除named window中的事件，那么事件应该存在生命周期，否则事件过多会有内存溢出的风险。所以我们在创建named window的时候会附带事件的过期策略，而各种过期策略就是用view来表达。named window的创建方式有三种：a.用已有的事件结构创建；b.自定义named window存放的事件格式；c.将已有的named window中包含的事件写入到新的named window中，即复制named window。

a.Creation by Modelling after an Existing Type
语法如下：

1. [context context_name] create window window_name.view_specifications [as] [select list_of_properties from] event

1）context是关键字，后面跟着之前定义的context的名称。关于context的内容，请参看《Esper学习之三：Context》
2）create window后跟着要创建的named window的名字，且具有唯一性。名字后面紧跟着的“.”是用来连接事件过期策略的，即view。常用的view有win:length，win:length_batch，win:time，win:time_batch，std:unique，std:groupwin及自定义view等等，并且特定的view可以连用。PS：view的相关内容我打算在EPL语法讲解完之后就为各位呈上，以免影响其他章节的学习。
3）select子句表示将某个事件定义中的全部或者某些属性作为named window所维护的事件属性。如果将某个事件的所有属性都加入到named window中，则可以通过select子句前的as连接事件名称，并且省略select子句。这个将在接下来的例子进行说明。

举几个例子说明下：

1. // FruitWindow保持最近10分钟的Apple事件
2. create window FruitWindow.win:time(10 min) as Apple
3. // FruitWindow保持最近5分钟的Apple事件，但只包含size和price属性
4. create window FruitWindow.win:time(5 min) as select size, price from Apple

b.Creation By Defining Columns Names and Types
和上一种创建方式不同，Esper允许自己指定named window能维护哪些属性，而不是通过别的事件定义来指定。语法如下：

1. [context context_name]
2. create window window_name.view_specifications [as] (column_name column_type[,column_name column_type [,...]])

column_name表示属性名称，column_type表示属性类型。属性可以是一个，也可以是多个，多个用逗号分隔。示例如下：

1. // 创建包含普通属性的named window
2. create window SecurityEvent.win:time(30 sec) (ipAddress string, userId String, numAttempts int, properties String[])
3. // 创建包含事件类型属性的named window
4. create schema SecurityData (name String, roles String[])
5. create window SecurityEvent.win:time(30 sec) (ipAddress string, userId String, secData SecurityData, historySecData SecurityData[])

c.Populating a Named Window from an Existing Named Window
     这一节在文档中并没有放到create named window里，不过我认为这也是一种创建方式，所以就放在这里讲解了。这种创建方式很容易懂，就是将已经存在的named window中的event写到新的named window中。语法如下：

1. [context context_name] create window window_name.view_specifications as windowname insert [where filter_expression]

windowname后面紧跟insert，表示将该window中的事件插入到新建的named window中。where filter_expression表示过滤插入的事件。实例如下：

1. create window ScratchBuyOrders.win:time(10) as OrdersNamedWindow insert where side = 'buy'

以上就是三种创建方式，另外还有一个注解的使用，可以使触发时往Listener中传入的事件是数组或者map形式。这个需要各位自己调试的时候才能看到效果。实例如下：

1. // 以数组形式反馈给UpdateListener
2. @EventRepresentation(array=true)create window FooWindow.win:time(5 sec) as (string prop1)
3. // 以Map形式反馈给UpdateListener
4. @EventRepresentation(array=false)create window FooWindow.win:time(5 sec) as (string prop1)
5. ... equals ...
6. create window FooWindow.win:time(5 sec) as (string prop1)

 

2.Inserting Into Named Windows

创建好named window以后，我们就可以往里面插入事件了。插入的语法很简单，基本上和insert into语法一样。关于insert into，请参见《Esper学习之八：EPL语法（四）》。下面直接举几个例子：

1. 1）
2. // create named window with some properties of OrderEvent
3. create window OrdersWindow.win:keepall() as select symbol, volume, price from OrderEvent
4. // insert into events to named window
5. insert into OrdersWindow(symbol, volume, price) select name, count, price from FXOrderEvent
6. ... equals ...
7. insert into OrdersWindow select name as symbol, vol as volume, price from FXOrderEvent
8. 2）
9. // create named window with POJO
10. create window OrdersWindow.win:time(30) as com.mycompany.OrderEvent
11. // insert into events to named window
12. insert into OrdersWindow select * from com.mycompany.OrderEvent(symbol='IBM')
13. 3）
14. // create named window
15. create window OrdersWindow.win:time(30) as select *, price as derivedPrice from OrderEvent
16. // insert into events to named window with custom function
17. insert into OrdersWindow select *, MyFunc.func(price, percent) as derivedPrice from OrderEvent
18. 4）
19. // create named window
20. create window OrdersWindow.win:time(30) as select *, price as priceTotal from OrderEvent
21. // insert into events to named window
22. insert into OrdersWindow select *, price * unit as priceTotal from ServiceOrderEvent
23. 5)
24. // create a named window for the base class
25. create window OrdersWindow.std:unique(name) as select * from ProductBaseEvent
26. // The ServiceProductEvent class subclasses the ProductBaseEvent class
27. insert into OrdersWindow select * from ServiceProductEvent
28. 6）
29. /**
30. * interface InterfaceEvent {
31. *         public int getPrice();
32. *         public String getName();
33. * }
34. */
35. // create a named window for the inteface
36. create window InterfaceWindow.win: time(2 sec) as select * from InterfaceEvent
37. // The InterfaceEventImpl is the implements for InterfaceEvent
38. insert into InterfaceWindow select * from InterfaceEventImpl

从以上几个例子可以看得出，创建named window时用的事件类型只是用了该事件类型的属性定义，只要insert的事件列出了对应的属性名称就可以，当然属性的数据类型也得对应。如果属性名不对应，可以用as来重命名，就像例3和例4那样。第5个例子表明子类可以插入到父类定义的named window中。第六个例子表明实现类可以插入到用接口定义的named window中。

3.Selecting From Named Windows

这一节主要讲解如何查询named window中的事件。准确来说这并不是一种无条件的查询方式，监听器监听查询语句以后，必须发送对应的事件(创建window时指定的事件类型)，然后先看是否满足named window的输出条件，再看是否满足查询语句的输出条件，所以并不是named window中的事件都会发给监听器。咱们先看一个例子：

1. // first, you should create the AllOrdersNamedWindow
2. create named window AllOrdersNamedWindow.win:length_batch(3) as OrderEvent
3. select * from AllOrdersNamedWindow

这个select句子看似很简单，实际上并不是查询AllOrdersNamedWindow中的事件。实际过程是这样的：首先引擎检查AllOrdersNamedWindow中有多少事件，因为过期策略是length_batch(3），意思是当AllOrdersNamedWindow中包含3个事件，才会将这3个事件同时输出，然后再等待新的3个事件，然后再一起输出这3个事件。。。所以当输入某一个事件时，若不满足3个数量，则select语句不会返回任何内容。若满足3个数量，则监听select语句的监听器会得到AllOrdersNamedWindow中的最新的3各事件。

下面的几个句子都只有在length_batch(3)满足条件时才能有事件输出。

如果想查到上一次过期的3个事件，则查询语句改成下面的样子：

1. select rstream * from AllOrdersNamedWindow

如果只想查询AllOrdernamedWindow里面的某几个属性，并且加上一些限制条件查看特定的事件，则查询语句改成下面的样子：

1. select symbol, avg(price) from AllOrdersNamedWindow(sector='energy')  group by symbol

因为上面所说的特点，所以查询语句可以在事件发送后再建立，也就是说我什么时候想查什么时候再建句子，named windows里有多少事件就如实返回多少。下面举个完整的例子总结一下：

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPRuntime;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EPStatement;
7. import com.espertech.esper.client.EventBean;
8. import com.espertech.esper.client.UpdateListener;
9. /**
10. * Created by Luonanqin on 3/19/14.
11. */
12. class SelectEvent {
13. private int price;
14. private String name;
15. public int getPrice() {
16. return price;
17. }
18. public void setPrice(int price) {
19. this.price = price;
20. }
21. public String getName() {
22. return name;
23. }
24. public void setName(String name) {
25. this.name = name;
26. }
27. @Override
28. public String toString() {
29. return "name="+name+", price="+price;
30. }
31. }
32. class SelectNamedWindowListener implements UpdateListener{
33. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
34. if (newEvents != null) {
35. System.out.println("There is "+newEvents.length+" events to be return!");
36. for (int i = 0;  i < newEvents.length;i++) {
37. System.out.println(newEvents[i].getUnderlying());
38. }
39. }
40. }
41. }
42. public class SelectNamedWindowTest{
43. public static void main(String[] args) {
44. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
45. EPAdministrator admin = epService.getEPAdministrator();
46. EPRuntime runtime = epService.getEPRuntime();
47. String selectEvent = SelectEvent.class.getName();
48. String epl1 = "create window SelectNamedWindow.win:length_batch(3) as " + selectEvent;
49. admin.createEPL(epl1);
50. System.out.println("Create named window: create window SelectNamedWindow.win:length_batch(3) as "+selectEvent);
51. String epl2 = "insert into SelectNamedWindow select * from " + selectEvent;
52. admin.createEPL(epl2);
53. SelectEvent se1 = new SelectEvent();
54. se1.setName("se1");
55. se1.setPrice(1);
56. System.out.println("Send SelecEvent1 " + se1);
57. runtime.sendEvent(se1);
58. SelectEvent se2 = new SelectEvent();
59. se2.setName("se2");
60. se2.setPrice(2);
61. System.out.println("Send SelecEvent2 " + se2);
62. runtime.sendEvent(se2);
63. // Can't create "select * from SelectamedWindow.win:time(3 sec)"
64. String epl3 = "select * from SelectNamedWindow(price>=2)";
65. EPStatement state3 = admin.createEPL(epl3);
66. state3.addListener(new SelectNamedWindowListener());
67. System.out.println("Register select sentence: select * from SelectNamedWindow(price>=2)");
68. SelectEvent se3 = new SelectEvent();
69. se3.setName("se3");
70. se3.setPrice(3);
71. System.out.println("Send SelecEvent3 " + se3 + "\n");
72. runtime.sendEvent(se3);
73. }
74. }

执行结果：

1. Create named window: create window SelectNamedWindow.win:length_batch(3) as example.SelectEvent
2. Send SelecEvent1 name=se1, price=1
3. Send SelecEvent2 name=se2, price=2
4. Register select sentence: select * from SelectNamedWindow(price>=2)
5. Send SelecEvent3 name=se3, price=3
6. There is 2 events to be return!
7. name=se2, price=2
8. name=se3, price=3

上面的例子有一段注释“select * from SelectamedWindow.win:time(3 sec)”，实际上是因为win:time(3 sec)这个东西，之前create named window的时候，已经使用了一个win的view，所以这里就不能再使用win的view了。这个与view相关，就一笔带过了。另外还有一点，在select句子中的filter如果使用了variable，当变量的值在句子创建后改变了，引擎不会读取新的值，这个需要额外注意。

4.Triggered Select on Named Windows：On Select

上一节说到的查询方式实际上并不是很好用，而这一节就提供了一个非常简单的查询办法。他是通过发送一个触发事件即可得到当前window里有些什么事件，你还可以设置这个触发事件满足什么要求才可触发，或者这个触发事件和window中的事件达到某种关联后输出符合这个关联的事件或事件的部分属性。先来看看语法：

1. on event_type[(filter_criteria)] [as stream_name]
2. select select_list from window_name [as stream_name]
3. [where criteria_expression] [group by grouping_expression_list] [having grouping_search_conditions] [order by order_by_expression_list]

event_type表示用来触发的事件，可以是任何一种事件类型，也可以是pattern（用来表达较为复杂的触发条件）。后面用括号括起来的包含了触发事件的限制条件，必须满足这个里面约定的条件才可用来触发查询。as stream_name为可选参数，主要用于具体的查询语句或者与window做关联用。select语句就不说了，和普通的没太大区别。后面的where条件限制了查询结果，满足结果的才可返回给监听器。group by、having、order by和之前说的用法一样，这里不做说明了。我们先来看几个简单的例子：

1. // QueryEvent作为触发事件，查询OrderNamedWindow中的所有事件，并附带触发的事件作为结果返回（什么意思？）
2. on QueryEvent select * from OrdersNamedWindow
3. // QueryEvent作为触发事件，查询OrderNamedWindow中的所有事件作为结果返回（懂了吧）
4. on QueryEvent select win.* from OrdersNamedWindow as win
5. // volume大于0的QueryEvent作为触发事件，查询OrderNamedWindow中的事件，且事件的symbol要与QueryEvent的symbol一样，返回满足条件的window事件的symbol值，以及QueryEvent的symbol和volume值
6. on QueryEvent(volume>0) as query
7. select query.symbol, query.volume, win.symbol from OrdersNamedWindow as win
8. where win.symbol = query.symbol
9. // group by, having, order by的用法与前面所讲无差别，都是针对查询出来的事件
10. on QueryEvent
11. select symbol, sum(volume) from OrdersNamedWindow as win
12. group by symbol having volume > 0 order by symbol
13. // 每一次OrderNamedWindow有变化并满足限制条件即可触发监听器返回window中的事件。
14. on OrdersNamedWindow as trig
15. select onw.symbol, sum(onw.volume) from OrdersNamedWindow as onw
16. where onw.symbol = trig.symbol

前两个例子我相信大家已经明白了。如果select子句里是*，则返回的不仅仅是window中的事件，还会返回触发查询的事件，并且返回的多行结果中每行都会包含这个触发事件。第三个例子可以看出as的用法。最后一个例子有些特别，触发的事件就是named window本身，目的就是为了named window变化了就能返回变化后的结果。但是这里的“变化”不是简单的事件有增加或者减少，而是指named window定义时指定的view达到触发条件有输出了，你才能真的看到查询结果。下面列一个完整的例子来概括一下上面说到的几点内容：

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPRuntime;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EPStatement;
7. import com.espertech.esper.client.EventBean;
8. import com.espertech.esper.client.UpdateListener;
9. /**
10. * Created by Luonanqin on 3/29/14.
11. */
12. class OnSelectTrigger {
13. private int trigger;
14. public int getTrigger() {
15. return trigger;
16. }
17. public void setTrigger(int trigger) {
18. this.trigger = trigger;
19. }
20. public String toString() {
21. return "trigger=" + trigger;
22. }
23. }
24. class OnSelectEvent {
25. private String name;
26. private int size;
27. public String getName() {
28. return name;
29. }
30. public void setName(String name) {
31. this.name = name;
32. }
33. public int getSize() {
34. return size;
35. }
36. public void setSize(int size) {
37. this.size = size;
38. }
39. public String toString() {
40. return "name=" + name + ", size=" + size;
41. }
42. }
43. class OnSelectWindowListener implements UpdateListener {
44. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
45. if (newEvents != null) {
46. System.out.println("Trigger On Select:");
47. System.out.println("There is " + newEvents.length + " OnSelectEvent in OnSelectWindow!");
48. for (int i = 0; i < newEvents.length; i++) {
49. System.out.println(newEvents[i].getUnderlying());
50. }
51. }
52. }
53. }
54. public class OnSelectWindowTest {
55. public static void main(String[] args) {
56. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
57. EPAdministrator admin = epService.getEPAdministrator();
58. EPRuntime runtime = epService.getEPRuntime();
59. String triggerEvent = OnSelectTrigger.class.getName();
60. String selectEvent = OnSelectEvent.class.getName();
61. // win:keepall()使named window中的事件一直保留
62. // String epl1 = "create window OnSelectWindow.win:keepall() as select * from " + selectEvent;
63. String epl1 = "create window OnSelectWindow.win:length(2) as select * from " + selectEvent;
64. String epl2 = "insert into OnSelectWindow select * from " + selectEvent;
65. String epl3 = "on " + triggerEvent + "(trigger>=2) select osw.* from OnSelectWindow as osw";
66. System.out.println("Create Window:" + epl1);
67. System.out.println("Trigger sentence: " + epl3);
68. System.out.println();
69. admin.createEPL(epl1);
70. admin.createEPL(epl2);
71. EPStatement state3 = admin.createEPL(epl3);
72. state3.addListener(new OnSelectWindowListener());
73. OnSelectEvent ose1 = new OnSelectEvent();
74. ose1.setName("ose1");
75. ose1.setSize(1);
76. runtime.sendEvent(ose1);
77. System.out.println("Send OnSelectEvent 1: " + ose1);
78. OnSelectEvent ose2 = new OnSelectEvent();
79. ose2.setName("ose2");
80. ose2.setSize(2);
81. runtime.sendEvent(ose2);
82. System.out.println("Send OnSelectEvent 2: " + ose2);
83. OnSelectEvent ose3 = new OnSelectEvent();
84. ose3.setName("ose3");
85. ose3.setSize(3);
86. runtime.sendEvent(ose3);
87. System.out.println("Send OnSelectEvent 3: " + ose3);
88. OnSelectTrigger ost1 = new OnSelectTrigger();
89. ost1.setTrigger(1);
90. System.out.println("Send OnSelectTrigger " + ost1);
91. runtime.sendEvent(ost1);
92. OnSelectTrigger ost2 = new OnSelectTrigger();
93. ost2.setTrigger(2);
94. System.out.println("Send OnSelectTrigger " + ost2 + "\n");
95. runtime.sendEvent(ost2);
96. System.out.println();
97. String epl4 = "on OnSelectWindow select osw.* from OnSelectWindow as osw";
98. EPStatement state4 = admin.createEPL(epl4);
99. state4.addListener(new OnSelectWindowListener());
100. System.out.println("Trigger sentence: " + epl4 + "\n");
101. OnSelectEvent ose4 = new OnSelectEvent();
102. ose4.setName("ose4");
103. ose4.setSize(4);
104. System.out.println("Send OnSelectEvent 4(also a Trigger): " + ose4 + "\n");
105. runtime.sendEvent(ose4);
106. System.out.println();
107. OnSelectEvent ose5 = new OnSelectEvent();
108. ose5.setName("ose5");
109. ose5.setSize(5);
110. System.out.println("Send OnSelectEvent 5(also a Trigger): " + ose5 + "\n");
111. runtime.sendEvent(ose5);
112. }
113. }

执行结果：

1. Create Window:create window OnSelectWindow.win:length(2) as select * from example.OnSelectEvent
2. Trigger sentence: on example.OnSelectTrigger(trigger>=2) select osw.* from OnSelectWindow as osw
3. Send OnSelectEvent 1: name=ose1, size=1
4. Send OnSelectEvent 2: name=ose2, size=2
5. Send OnSelectEvent 3: name=ose3, size=3
6. Send OnSelectTrigger trigger=1
7. Send OnSelectTrigger trigger=2
8. Trigger On Select:
9. There is 2 OnSelectEvent in OnSelectWindow!
10. name=ose2, size=2
11. name=ose3, size=3
12. Trigger sentence: on OnSelectWindow select osw.* from OnSelectWindow as osw
13. Send OnSelectEvent 4(also a Trigger): name=ose4, size=4
14. Trigger On Select:
15. There is 2 OnSelectEvent in OnSelectWindow!
16. name=ose3, size=3
17. name=ose4, size=4
18. Send OnSelectEvent 5(also a Trigger): name=ose5, size=5
19. Trigger On Select:
20. There is 2 OnSelectEvent in OnSelectWindow!
21. name=ose4, size=4
22. name=ose5, size=5

 

5.Triggered Delete on Named Windows：On Delete

除了可以用on select语句查询named window，还可以用on delete语句删除named window中的事件。语法和on select基本一样，同样能够设置一定条件限制触发事件，以及删除符合特定条件的事件。语法如下：

1. on event_type[(filter_criteria)] [as stream_name] delete from window_name [as stream_name]
2. [where criteria_expression]

和on select不同的是，delete后面不跟属性什么的，因为删除的就是事件，不存在删除事件中的某些属性这种情况。filter_criteria用来限制触发事件，where criteria_expression用来限制要删除的事件。而且没有group by, having, Order by。举例如下：

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPRuntime;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EPStatement;
7. import com.espertech.esper.client.EventBean;
8. import com.espertech.esper.client.UpdateListener;
9. /**
10. * Created by Luonanqin on 3/30/14.
11. */
12. class OnDeleteTrigger {
13. private int trigger;
14. public int getTrigger() {
15. return trigger;
16. }
17. public void setTrigger(int trigger) {
18. this.trigger = trigger;
19. }
20. public String toString() {
21. return "trigger=" + trigger;
22. }
23. }
24. class OnDeleteEvent {
25. private String name;
26. private int size;
27. public String getName() {
28. return name;
29. }
30. public void setName(String name) {
31. this.name = name;
32. }
33. public int getSize() {
34. return size;
35. }
36. public void setSize(int size) {
37. this.size = size;
38. }
39. public String toString() {
40. return "name=" + name + ", size=" + size;
41. }
42. }
43. class OnDeleteWindowListener implements UpdateListener {
44. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
45. if (newEvents != null) {
46. System.out.println();
47. System.out.println("Trigger On Delete:");
48. System.out.println("There is " + newEvents.length + " OnDeleteEvent to be deleted in OnDeleteWindow!");
49. for (int i = 0; i < newEvents.length; i++) {
50. System.out.println(newEvents[i].getUnderlying());
51. }
52. }
53. }
54. }
55. class OnSelectListener implements UpdateListener{
56. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
57. if (newEvents != null) {
58. System.out.println();
59. System.out.println("Trigger On Select:");
60. System.out.println("There is " + newEvents.length + " OnDeleteEvent in OnDeleteWindow!");
61. for (int i = 0; i < newEvents.length; i++) {
62. System.out.println(newEvents[i].getUnderlying());
63. }
64. }
65. }
66. }
67. public class OnDeleteWindowTest {
68. public static void main(String[] args) {
69. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
70. EPAdministrator admin = epService.getEPAdministrator();
71. EPRuntime runtime = epService.getEPRuntime();
72. String triggerEvent = OnDeleteTrigger.class.getName();
73. String deleteEvent = OnDeleteEvent.class.getName();
74. String epl1 = "create window OnDeleteWindow.win:keepall() as select * from " + deleteEvent;
75. String epl2 = "insert into OnDeleteWindow select * from " + deleteEvent;
76. String epl3 = "on " + triggerEvent + "(trigger>0) as odt delete from OnDeleteWindow as odw where odt.trigger=odw.size";
77. String epl4 = "on " + triggerEvent + "(trigger=0) select odw.* from OnDeleteWindow as odw";
78. System.out.println("Create Window: " + epl1);
79. System.out.println("Delete Trigger: " + epl3);
80. System.out.println("Select Trigger: " + epl4);
81. System.out.println();
82. admin.createEPL(epl1);
83. admin.createEPL(epl2);
84. EPStatement state3 = admin.createEPL(epl3);
85. state3.addListener(new OnDeleteWindowListener());
86. EPStatement state4 = admin.createEPL(epl4);
87. state4.addListener(new OnSelectListener());
88. OnDeleteEvent ose1 = new OnDeleteEvent();
89. ose1.setName("ose1");
90. ose1.setSize(1);
91. runtime.sendEvent(ose1);
92. System.out.println("Send OnDeleteEvent 1: " + ose1);
93. OnDeleteEvent ose2 = new OnDeleteEvent();
94. ose2.setName("ose2");
95. ose2.setSize(2);
96. runtime.sendEvent(ose2);
97. System.out.println("Send OnDeleteEvent 2: " + ose2);
98. OnDeleteEvent ose3 = new OnDeleteEvent();
99. ose3.setName("ose3");
100. ose3.setSize(3);
101. runtime.sendEvent(ose3);
102. System.out.println("Send OnDeleteEvent 3: " + ose3);
103. OnDeleteTrigger ost1 = new OnDeleteTrigger();
104. ost1.setTrigger(0);
105. System.out.println("\nSend OnSelectTrigger " + ost1);
106. runtime.sendEvent(ost1);
107. OnDeleteTrigger ost2 = new OnDeleteTrigger();
108. ost2.setTrigger(2);
109. System.out.println("\nSend OnDeleteTrigger " + ost2);
110. runtime.sendEvent(ost2);
111. OnDeleteTrigger ost3 = new OnDeleteTrigger();
112. ost3.setTrigger(0);
113. System.out.println("\nSend OnSelectTrigger " + ost3);
114. runtime.sendEvent(ost3);
115. }
116. }

执行结果：

1. Create Window: create window OnDeleteWindow.win:keepall() as select * from example.OnDeleteEvent
2. Delete Trigger: on example.OnDeleteTrigger(trigger>0) as odt delete from OnDeleteWindow as odw where odt.trigger=odw.size
3. Select Trigger: on example.OnDeleteTrigger(trigger=0) select odw.* from OnDeleteWindow as odw
4. Send OnDeleteEvent 1: name=ose1, size=1
5. Send OnDeleteEvent 2: name=ose2, size=2
6. Send OnDeleteEvent 3: name=ose3, size=3
7. Send OnSelectTrigger trigger=0
8. Trigger On Select:
9. There is 3 OnDeleteEvent in OnDeleteWindow!
10. name=ose1, size=1
11. name=ose2, size=2
12. name=ose3, size=3
13. Send OnDeleteTrigger trigger=2
14. Trigger On Delete:
15. There is 1 OnDeleteEvent to be deleted in OnDeleteWindow!
16. name=ose2, size=2
17. Send OnSelectTrigger trigger=0
18. Trigger On Select:
19. There is 2 OnDeleteEvent in OnDeleteWindow!
20. name=ose1, size=1
21. name=ose3, size=3

 

6.Triggered Select+Delete on Named Windows: the On Select Delete

如果我们想在从named window查询出结果的同时删掉查询结果，那么可以使用on select and delete语句。语法和on select语句几乎是一样的，只是多了个delete。语法如下：

1. on trigger
2. select [and] delete select_list...
3. ... (please see on-select for from, group by, having, order by)...

直接上一个完整例子：

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPRuntime;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EPStatement;
7. import com.espertech.esper.client.EventBean;
8. import com.espertech.esper.client.UpdateListener;
9. /**
10. * Created by Luonanqin on 3/29/14.
11. */
12. class OnSelectDeleteTrigger {
13. private int trigger;
14. public int getTrigger() {
15. return trigger;
16. }
17. public void setTrigger(int trigger) {
18. this.trigger = trigger;
19. }
20. public String toString() {
21. return "trigger=" + trigger;
22. }
23. }
24. class OnSelectDeleteEvent {
25. private String name;
26. private int size;
27. public String getName() {
28. return name;
29. }
30. public void setName(String name) {
31. this.name = name;
32. }
33. public int getSize() {
34. return size;
35. }
36. public void setSize(int size) {
37. this.size = size;
38. }
39. public String toString() {
40. return "name=" + name + ", size=" + size;
41. }
42. }
43. class OnSelectDeleteWindowListener implements UpdateListener {
44. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
45. if (newEvents != null) {
46. System.out.println();
47. System.out.println("Trigger On Select and Delete:");
48. System.out.println("There is " + newEvents.length + " OnSelectDeleteEvent in OnSelectDeleteWindow!");
49. for (int i = 0; i < newEvents.length; i++) {
50. System.out.println(newEvents[i].getUnderlying());
51. }
52. }
53. }
54. }
55. public class OnSelectDeleteWindowTest {
56. public static void main(String[] args) {
57. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
58. EPAdministrator admin = epService.getEPAdministrator();
59. EPRuntime runtime = epService.getEPRuntime();
60. String triggerEvent = OnSelectDeleteTrigger.class.getName();
61. String selectDeleteEvent = OnSelectDeleteEvent.class.getName();
62. String epl1 = "create window OnSelectDeleteWindow.win:keepall() as select * from " + selectDeleteEvent;
63. String epl2 = "insert into OnSelectDeleteWindow select * from " + selectDeleteEvent;
64. String epl3 = "on " + triggerEvent + " select and delete osw.* from OnSelectDeleteWindow as osw";
65. System.out.println("Create Window: " + epl1);
66. System.out.println("Select and Delete Trigger: " + epl3);
67. System.out.println();
68. admin.createEPL(epl1);
69. admin.createEPL(epl2);
70. EPStatement state3 = admin.createEPL(epl3);
71. state3.addListener(new OnSelectDeleteWindowListener());
72. OnSelectDeleteEvent osde1 = new OnSelectDeleteEvent();
73. osde1.setName("osde1");
74. osde1.setSize(1);
75. runtime.sendEvent(osde1);
76. System.out.println("Send OnSelectDeleteEvent 1: " + osde1);
77. OnSelectDeleteEvent osde2 = new OnSelectDeleteEvent();
78. osde2.setName("osde2");
79. osde2.setSize(2);
80. runtime.sendEvent(osde2);
81. System.out.println("Send OnSelectDeleteEvent 2: " + osde2);
82. OnSelectDeleteEvent osde3 = new OnSelectDeleteEvent();
83. osde3.setName("osde3");
84. osde3.setSize(3);
85. runtime.sendEvent(osde3);
86. System.out.println("Send OnSelectDeleteEvent 3: " + osde3);
87. OnSelectDeleteTrigger osdt1 = new OnSelectDeleteTrigger();
88. osdt1.setTrigger(1);
89. System.out.println("Send OnSelectDeleteTrigger " + osdt1);
90. runtime.sendEvent(osdt1);
91. System.out.println();
92. OnSelectDeleteEvent osde4 = new OnSelectDeleteEvent();
93. osde4.setName("osde4");
94. osde4.setSize(4);
95. System.out.println("Send OnSelectDeleteEvent 4: " + osde4);
96. runtime.sendEvent(osde4);
97. OnSelectDeleteTrigger osdt2 = new OnSelectDeleteTrigger();
98. osdt2.setTrigger(1);
99. System.out.println("Send OnSelectDeleteTrigger " + osdt2);
100. runtime.sendEvent(osdt2);
101. }
102. }

执行结果：

1. Create Window: create window OnSelectDeleteWindow.win:keepall() as select * from example.OnSelectDeleteEvent
2. Select and Delete Trigger: on example.OnSelectDeleteTrigger select and delete osw.* from OnSelectDeleteWindow as osw
3. Send OnSelectDeleteEvent 1: name=osde1, size=1
4. Send OnSelectDeleteEvent 2: name=osde2, size=2
5. Send OnSelectDeleteEvent 3: name=osde3, size=3
6. Send OnSelectDeleteTrigger trigger=1
7. Trigger On Select and Delete:
8. There is 3 OnSelectDeleteEvent in OnSelectDeleteWindow!
9. name=osde1, size=1
10. name=osde2, size=2
11. name=osde3, size=3
12. Send OnSelectDeleteEvent 4: name=osde4, size=4
13. Send OnSelectDeleteTrigger trigger=1
14. Trigger On Select and Delete:
15. There is 1 OnSelectDeleteEvent in OnSelectDeleteWindow!
16. name=osde4, size=4

 

7.Updating Named Windows: the On Update clause

除了查询和删除window里的事件，我们还可以更新事件，而且同样也是通过发送一个特定事件来出发更新操作。语法如下：

1. on event_type[(filter_criteria)] [as stream_name]
2. update window_name [as stream_name]
3. set property_name = expression [, property_name = expression [,...]] [where criteria_expression]

filter_criteria用来过滤触发事件，criteria_expression用来过滤window中的事件不予更改。和sql类似，set后面跟着要修改的属性及要赋的值，多个属性名值对用逗号分隔。先看一个简单的例子：

1. on NewOrderEvent(volume>0) as myNewOrders
2. update AllOrdersNamedWindow as myNamedWindow set price = myNewOrders.price
3. where myNamedWindow.symbol = myNewOrders.symbol

我想不用做太多解释大家就能很容易看懂。不过下面这个例子呢：

1. on UpdateEvent as upd
2. update MyWindow as win
3. set field_a = 1,
4. field_b = win.field_a, // assigns the value 1
5. field_c = initial.field_a // assigns the field_a original value before update

上面的例子中，field_a被更新为1，然后用修改后的field_a赋值给field_b，那么field_b实际上也变成1了。但是如果想用更新前的field_a的值赋给field_c，那么就要写成initial.field_a。initial是关键字，所以不能省略。
我们可以用监听器监听on update语句，返回给监听器的就是被更新的事件。结合上面的两点内容，我们来看一个完整的例子：

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPRuntime;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EPStatement;
7. import com.espertech.esper.client.EventBean;
8. import com.espertech.esper.client.UpdateListener;
9. import java.io.Serializable;
10. /**
11. * Created by Luonanqin on 4/5/14.
12. */
13. class OnUpdateTrigger {
14. private int trigger;
15. public int getTrigger() {
16. return trigger;
17. }
18. public void setTrigger(int trigger) {
19. this.trigger = trigger;
20. }
21. public String toString() {
22. return "trigger=" + trigger;
23. }
24. }
25. class OnUpdateEvent implements Serializable{
26. private String name;
27. private int size;
28. private int price;
29. public int getPrice() {
30. return price;
31. }
32. public void setPrice(int price) {
33. this.price = price;
34. }
35. public String getName() {
36. return name;
37. }
38. public void setName(String name) {
39. this.name = name;
40. }
41. public int getSize() {
42. return size;
43. }
44. public void setSize(int size) {
45. this.size = size;
46. }
47. public String toString() {
48. return "name=" + name + ", size=" + size + ", price=" + price;
49. }
50. }
51. class OnUpdateWindowListener implements UpdateListener {
52. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
53. if (newEvents != null) {
54. System.out.println();
55. System.out.println("Trigger On Update:");
56. System.out.println("There is " + newEvents.length + " to be updated in OnUpdateWindow!");
57. for (int i = 0; i < newEvents.length; i++) {
58. System.out.println(newEvents[i].getUnderlying());
59. }
60. }
61. }
62. }
63. class OnUpdateSelectWindowListener implements UpdateListener {
64. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
65. if (newEvents != null) {
66. System.out.println();
67. System.out.println("Trigger On Select:");
68. System.out.println("There is " + newEvents.length + " OnUpdateEvent in OnUpdateWindow!");
69. for (int i = 0; i < newEvents.length; i++) {
70. System.out.println(newEvents[i].getUnderlying());
71. }
72. }
73. }
74. }
75. public class OnUpdateWindowTest {
76. public static void main(String[] args) {
77. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
78. EPAdministrator admin = epService.getEPAdministrator();
79. EPRuntime runtime = epService.getEPRuntime();
80. String triggerEvent = OnUpdateTrigger.class.getName();
81. String updateEvent = OnUpdateEvent.class.getName();
82. String epl1 = "create window OnUpdateWindow.win:keepall() as select * from " + updateEvent;
83. String epl2 = "insert into OnUpdateWindow select * from " + updateEvent;
84. String epl3 = "on " + triggerEvent + "(trigger>0) as out update OnUpdateWindow as ouw set size=out.trigger, price=initial.size where out.trigger<ouw.price";
85. String epl4 = "on " + triggerEvent + "(trigger=0) select ouw.* from OnUpdateWindow as ouw";
86. System.out.println("Create Window: " + epl1);
87. System.out.println("Update Trigger sentence: " + epl3);
88. System.out.println();
89. admin.createEPL(epl1);
90. admin.createEPL(epl2);
91. EPStatement state3 = admin.createEPL(epl3);
92. state3.addListener(new OnUpdateWindowListener());
93. EPStatement state4 = admin.createEPL(epl4);
94. state4.addListener(new OnUpdateSelectWindowListener());
95. OnUpdateEvent oue1 = new OnUpdateEvent();
96. oue1.setName("oue1");
97. oue1.setSize(1);
98. oue1.setPrice(2);
99. runtime.sendEvent(oue1);
100. System.out.println("Send OnUpdateEvent 1: " + oue1);
101. OnUpdateEvent oue2 = new OnUpdateEvent();
102. oue2.setName("oue2");
103. oue2.setSize(2);
104. oue2.setPrice(3);
105. runtime.sendEvent(oue2);
106. System.out.println("Send OnUpdateEvent 2: " + oue2);
107. OnUpdateEvent oue3 = new OnUpdateEvent();
108. oue3.setName("oue3");
109. oue3.setSize(3);
110. oue3.setPrice(4);
111. runtime.sendEvent(oue3);
112. System.out.println("Send OnUpdateEvent 3: " + oue3);
113. OnUpdateTrigger ost1 = new OnUpdateTrigger();
114. ost1.setTrigger(0);
115. System.out.println("\nSend OnUpdateTrigger " + ost1);
116. runtime.sendEvent(ost1);
117. OnUpdateTrigger ost2 = new OnUpdateTrigger();
118. ost2.setTrigger(2);
119. System.out.println("\nSend OnUpdateTrigger " + ost2);
120. runtime.sendEvent(ost2);
121. OnUpdateTrigger ost3 = new OnUpdateTrigger();
122. ost3.setTrigger(0);
123. System.out.println("\nSend OnUpdateTrigger " + ost3);
124. runtime.sendEvent(ost3);
125. }
126. }

执行结果：

1. Create Window: create window OnUpdateWindow.win:keepall() as select * from example.OnUpdateEvent
2. Update Trigger sentence: on example.OnUpdateTrigger(trigger>0) as out update OnUpdateWindow as ouw set size=out.trigger, price=initial.size where out.trigger<ouw.price
3. Send OnUpdateEvent 1: name=oue1, size=1, price=2
4. Send OnUpdateEvent 2: name=oue2, size=2, price=3
5. Send OnUpdateEvent 3: name=oue3, size=3, price=4
6. Send OnUpdateTrigger trigger=0
7. Trigger On Select:
8. There is 3 OnUpdateEvent in OnUpdateWindow!
9. name=oue1, size=1, price=2
10. name=oue2, size=2, price=3
11. name=oue3, size=3, price=4
12. Send OnUpdateTrigger trigger=2
13. Trigger On Update:
14. There is 2 to be updated in OnUpdateWindow!
15. name=oue2, size=2, price=2
16. name=oue3, size=2, price=3
17. Send OnUpdateTrigger trigger=0
18. Trigger On Select:
19. There is 3 OnUpdateEvent in OnUpdateWindow!
20. name=oue1, size=1, price=2
21. name=oue2, size=2, price=2
22. name=oue3, size=2, price=3

OnUpdateEvent和平时我们定义的事件不太一样，它实现了Serializable接口。这是因为update更新属性前会复制一份同样的事件暂存，比如initial这种操作就需要更新前的值，所以就需要我们实现序列化接口。如果不想通过代码完成这个序列化要求，也可以通过配置完成，这个就不在这里说了。另外还有以下几点需要注意：
a）需要更新的属性一定要是可写的
b）XML格式的事件不能通过此语句更新
c）嵌套属性不支持更新

 

8.Triggered Upsert using the On-Merge Clause

除了上面的on select，on update，on delete操作，esper还支持on merge操作。他可以在满足不同条件的情况下完成对应的window中的事件的insert，update和delete操作，所以语法相对前面几种就复杂很多。语法如下：

1. on event_type[(filter_criteria)] [as stream_name] merge [into] window_name [as stream_name]
2. [where criteria_expression]
3. when [not] matched [and search_condition] then [
4. insert [into streamname] [ (property_name [, property_name] [,...]) ]
5. select select_expression [, select_expression[,...]] [where filter_expression]
6. |
7. update set property_name = expression [, property_name = expression [,...]] [where filter_expression]
8. |
9. delete [where filter_expression]
10. ]
11. [then [insert|update|delete]] [,then ...]
12. [when ...  then ... [...]]

a.第一行就不多说了，和前面的用法都一样。
b.第二行的where语句将事件分为了matched（满足where条件）和not matched（不满足where条件）两类
c.第三行的when配合matched或者not matched表示“window中满足where条件的事件，执行下面的操作/window中不满足where条件的事件，执行下面的操作”。search_condition为可选字段，表示再次过滤matched或not matched中的事件，只有没被过滤掉的事件才可以被then后面的语句操作。
d.第四行的insert语句和之前说的insert into不太一样。虽然都表示插入事件，但是由于into streamname是可选，所以在只有insert关键字的情况下，会将触发的事件插入到当前的named window中。如果要指明插入到别的named window中就要在insert之后带上into及window的名字。再之后的圆括号中的内容表示要插入的事件的属性，一般情况是在将事件插入到别的window中时，用它来重命名第五行中列出的属性。
e.第五行实际是配合第四行一起使用的。select子句不可少，不然引擎就不知道要往window中插入什么内容了。select的内容可以是*，也可以是属性列表。where语句再一次限制可插入的触发事件。注意select后面没有from，因为事件来源就是当时的触发事件。
f.第七行用来更新符合条件的事件，可更新单个或多个属性，where条件判断是否可进行更新操作。
g.第九行用来删除符合条件的事件，只包含关键字delete以及可选的where语句。
h.最后两行表示on merge中可以有多个when，每个when可以有多个then及insert或updata或delete语句，这样就能组成一个非常复杂的merge操作了。

语法内容有点多，但是应该都还容易理解吧。除了语法，还有几点需要注意的：
1. when not matched后面只能跟insert语句，而when matched则没有任何限制。
2. select语句中不能使用聚合函数。
3. 当某一个when matched或者no matched和其search_condition满足，则这个when下的所有then都会执行，并且按照顺序执行。
4. 避免在一个when中同时使用update和delete，esper不能保证两个都有效执行。

接下来我给大家一个完整的例子，各位可以好好揣摩一下上面所讲的要点。

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPRuntime;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EPStatement;
7. import com.espertech.esper.client.EventBean;
8. import com.espertech.esper.client.UpdateListener;
9. import java.io.Serializable;
10. import java.util.HashMap;
11. import java.util.Map;
12. /**
13. * Created by Luonanqin on 4/8/14.
14. */
15. class MergeEvent implements Serializable {
16. private int mergeId;
17. private String mergeStr;
18. private int mergeSize;
19. private boolean deleteFlag;
20. public int getMergeId() {
21. return mergeId;
22. }
23. public void setMergeId(int mergeId) {
24. this.mergeId = mergeId;
25. }
26. public String getMergeStr() {
27. return mergeStr;
28. }
29. public void setMergeStr(String mergeStr) {
30. this.mergeStr = mergeStr;
31. }
32. public int getMergeSize() {
33. return mergeSize;
34. }
35. public void setMergeSize(int mergeSize) {
36. this.mergeSize = mergeSize;
37. }
38. public boolean isDeleteFlag() {
39. return deleteFlag;
40. }
41. public void setDeleteFlag(boolean deleteFlag) {
42. this.deleteFlag = deleteFlag;
43. }
44. public String toString() {
45. return "mergeId=" + mergeId + ", mergeStr=" + mergeStr + ", mergeSize=" + mergeSize + ", deleteFlag=" + deleteFlag;
46. }
47. }
48. class OnMergeWindowlistener implements UpdateListener {
49. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
50. if (newEvents != null) {
51. System.out.println("Trigger MergeWindow:");
52. for (int i = 0; i < newEvents.length; i++) {
53. System.out.println(newEvents[i].getUnderlying());
54. }
55. }
56. }
57. }
58. class SelectLogWindowlistener implements UpdateListener {
59. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
60. if (newEvents != null) {
61. for (int i = 0; i < newEvents.length; i++) {
62. System.out.println(newEvents[i].getUnderlying());
63. }
64. }
65. }
66. }
67. class SelectMergeWindowlistener implements UpdateListener {
68. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
69. if (newEvents != null) {
70. for (int i = 0; i < newEvents.length; i++) {
71. System.out.println(newEvents[i].getUnderlying());
72. }
73. }
74. }
75. }
76. public class OnMergeWindowTest {
77. public static void main(String[] args) {
78. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
79. EPAdministrator admin = epService.getEPAdministrator();
80. EPRuntime runtime = epService.getEPRuntime();
81. String mergeEvent = MergeEvent.class.getName();
82. String epl1 = "create window MergeWindow.win:keepall() select * from " + mergeEvent;
83. String epl2 = "create schema LogEvent as (id int, name string)";
84. String epl3 = "create window LogWindow.win:keepall() as LogEvent";
85. String epl4 = "on " + mergeEvent + "(mergeSize > 0) me merge MergeWindow mw where me.mergeId = mw.mergeId "
86. + "when matched and me.deleteFlag = true then delete "
87. + "when matched then update set mergeSize = mergeSize + me.mergeSize where mw.mergeSize > 3 "
88. // MergeWindow中不存在的事件都会在触发merge时插入到window中，同时将部分属性插入到LogWindow中用于记录
89. + "when not matched then insert select * then insert into LogWindow(id, name) select me.mergeId, me.mergeStr";
90. String epl5 = "on LogEvent(id=0) select lw.* from LogWindow as lw";
91. String epl6 = "on " + mergeEvent + "(mergeSize = 0) select mw.* from MergeWindow as mw";
92. System.out.println("Create Window: " + epl1);
93. System.out.println("Merge Trigger: " + epl4);
94. System.out.println();
95. admin.createEPL(epl1);
96. admin.createEPL(epl2);
97. admin.createEPL(epl3);
98. EPStatement state1 = admin.createEPL(epl4);
99. state1.addListener(new OnMergeWindowlistener());
100. EPStatement state2 = admin.createEPL(epl5);
101. state2.addListener(new SelectLogWindowlistener());
102. EPStatement state3 = admin.createEPL(epl6);
103. state3.addListener(new SelectMergeWindowlistener());
104. Map<String, Object> selectLog = new HashMap<String, Object>();
105. selectLog.put("id", 0);
106. MergeEvent selectMerge = new MergeEvent();
107. selectMerge.setMergeSize(0);
108. MergeEvent me1 = new MergeEvent();
109. me1.setDeleteFlag(false);
110. me1.setMergeId(1);
111. me1.setMergeSize(2);
112. me1.setMergeStr("me1");
113. System.out.println("Send MergeEvent 1: " + me1);
114. runtime.sendEvent(me1);
115. MergeEvent me2 = new MergeEvent();
116. me2.setDeleteFlag(false);
117. me2.setMergeId(2);
118. me2.setMergeSize(3);
119. me2.setMergeStr("me2");
120. System.out.println("Send MergeEvent 2: " + me2);
121. runtime.sendEvent(me2);
122. MergeEvent me3 = new MergeEvent();
123. me3.setDeleteFlag(false);
124. me3.setMergeId(3);
125. me3.setMergeSize(4);
126. me3.setMergeStr("me3");
127. System.out.println("Send MergeEvent 3: " + me3);
128. runtime.sendEvent(me3);
129. /**
130. *  查询之前插入的三个事件
131. */
132. System.out.println("\nSend MergeEvent to Select MergeWindow!");
133. runtime.sendEvent(selectMerge);
134. /**
135. *  查询LogWindow中记录的MergeEvent部分属性
136. */
137. System.out.println("\nSend LogEvent to Select LogWindow!");
138. runtime.sendEvent(selectLog, "LogEvent");
139. /**
140. *  因为mergeId是3，所以MergeWindow中只有mergeId=3的事件有资格被更新。
141. *  并且mergeSize>3，所以可以执行更新操作。
142. */
143. MergeEvent me4 = new MergeEvent();
144. me4.setDeleteFlag(false);
145. me4.setMergeId(3);
146. me4.setMergeSize(5);
147. me4.setMergeStr("me4");
148. System.out.println("\nSend MergeEvent 4: " + me4);
149. runtime.sendEvent(me4);
150. System.out.println("\nSend MergeEvent to Select MergeWindow!");
151. runtime.sendEvent(selectMerge);
152. /**
153. *  因为mergeId是1，所以MergeWindow中只有mergeId=1的事件有资格被更新。
154. *  并且deleteFlag=true，所以mergeId=1的事件将从MergeWindow中移除
155. */
156. MergeEvent me5 = new MergeEvent();
157. me5.setDeleteFlag(true);
158. me5.setMergeId(1);
159. me5.setMergeSize(6);
160. me5.setMergeStr("me5");
161. System.out.println("\nSend MergeEvent 5: " + me5);
162. runtime.sendEvent(me5);
163. System.out.println("\nSend MergeEvent to Select MergeWindow!");
164. runtime.sendEvent(selectMerge);
165. }
166. }

执行结果：

1. Create Window: create window MergeWindow.win:keepall() select * from example.MergeEvent
2. Merge Trigger: on example.MergeEvent(mergeSize > 0) me merge MergeWindow mw where me.mergeId = mw.mergeId when matched and me.deleteFlag = true then delete when matched then update set mergeSize = mergeSize + me.mergeSize where mw.mergeSize > 3 when not matched then insert select * then insert into LogWindow(id, name) select me.mergeId, me.mergeStr
3. Send MergeEvent 1: mergeId=1, mergeStr=me1, mergeSize=2, deleteFlag=false
4. Trigger MergeWindow:
5. mergeId=1, mergeStr=me1, mergeSize=2, deleteFlag=false
6. Send MergeEvent 2: mergeId=2, mergeStr=me2, mergeSize=3, deleteFlag=false
7. Trigger MergeWindow:
8. mergeId=2, mergeStr=me2, mergeSize=3, deleteFlag=false
9. Send MergeEvent 3: mergeId=3, mergeStr=me3, mergeSize=4, deleteFlag=false
10. Trigger MergeWindow:
11. mergeId=3, mergeStr=me3, mergeSize=4, deleteFlag=false
12. Send MergeEvent to Select MergeWindow!
13. mergeId=1, mergeStr=me1, mergeSize=2, deleteFlag=false
14. mergeId=2, mergeStr=me2, mergeSize=3, deleteFlag=false
15. mergeId=3, mergeStr=me3, mergeSize=4, deleteFlag=false
16. Send LogEvent to Select LogWindow!
17. {id=1, name=me1}
18. {id=2, name=me2}
19. {id=3, name=me3}
20. Send MergeEvent 4: mergeId=3, mergeStr=me4, mergeSize=5, deleteFlag=false
21. Trigger MergeWindow:
22. mergeId=3, mergeStr=me3, mergeSize=9, deleteFlag=false
23. Send MergeEvent to Select MergeWindow!
24. mergeId=1, mergeStr=me1, mergeSize=2, deleteFlag=false
25. mergeId=2, mergeStr=me2, mergeSize=3, deleteFlag=false
26. mergeId=3, mergeStr=me3, mergeSize=9, deleteFlag=false
27. Send MergeEvent 5: mergeId=1, mergeStr=me5, mergeSize=6, deleteFlag=true
28. Send MergeEvent to Select MergeWindow!
29. mergeId=2, mergeStr=me2, mergeSize=3, deleteFlag=false
30. mergeId=3, mergeStr=me3, mergeSize=9, deleteFlag=false

 

9.Selecting/Updating/Deleting From Named Windows Using Fire-And-Forget Queries

上面对于named window的所有操作，都是要发送一个事件到引擎才可达到目的。那是否可以不发送事件直接执行select/update/delete语句达到目的呢？Esper确实为大家提供了一种简单的方式来操作named window。和之前说的有很大的不同，首先不需要发送任何事件到引擎即可select/update/delete，其次不需要监听器就可立即获得操作结果。4.9版本只支持这三种操作，不过现在的4.11已经增加了很多别的操作，详细内容请各位自己去看官方文档吧。由于本节内容较为简单，所以我直接给大家展示语法及一个完整的例子。

1. // select
2. select *[, property_name[,...]] from window_name [where criteria_expression] [oder by] [having] [subquery]
3. // update 子查询，聚合函数等不能用于expression
4. update window_name [as stream_name]
5. set property_name = expression [, property_name = expression [,...]] [where criteria_expression]
6. // delete
7. delete from window_name [as stream_name] [where criteria_expression]

1. package example;
2. import com.espertech.esper.client.EPAdministrator;
3. import com.espertech.esper.client.EPOnDemandQueryResult;
4. import com.espertech.esper.client.EPRuntime;
5. import com.espertech.esper.client.EPServiceProvider;
6. import com.espertech.esper.client.EPServiceProviderManager;
7. import com.espertech.esper.client.EventBean;
8. import java.io.Serializable;
9. /**
10. * Created by Luonanqin on 4/9/14.
11. */
12. class SelectEvent implements Serializable {
13. private String name;
14. private int size;
15. public String getName() {
16. return name;
17. }
18. public void setName(String name) {
19. this.name = name;
20. }
21. public int getSize() {
22. return size;
23. }
24. public void setSize(int size) {
25. this.size = size;
26. }
27. public String toString() {
28. return "name=" + name + ", size=" + size;
29. }
30. }
31. public class SelectWindowTest {
32. public static void main(String[] args) {
33. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
34. EPAdministrator admin = epService.getEPAdministrator();
35. EPRuntime runtime = epService.getEPRuntime();
36. String selectEvent = SelectEvent.class.getName();
37. String epl1 = "create window SelectWindow.win:keepall() as select * from " + selectEvent;
38. String epl2 = "insert into SelectWindow select * from " + selectEvent;
39. admin.createEPL(epl1);
40. admin.createEPL(epl2);
41. SelectEvent se1 = new SelectEvent();
42. se1.setName("se1");
43. se1.setSize(1);
44. runtime.sendEvent(se1);
45. System.out.println("Send SelectEvent 1: " + se1);
46. SelectEvent se2 = new SelectEvent();
47. se2.setName("se2");
48. se2.setSize(2);
49. runtime.sendEvent(se2);
50. System.out.println("Send SelectEvent 2: " + se2);
51. String select = "select * from SelectWindow";
52. String update = "update SelectWindow set name='update1' where size = 2";
53. String delete = "delete from SelectWindow where size < 2";
54. System.out.println("\nSelect SelectWindow!");
55. EPOnDemandQueryResult selectResult = epService.getEPRuntime().executeQuery(select);
56. EventBean[] events = selectResult.getArray();
57. for (int i = 0; i < events.length; i++) {
58. System.out.println(events[i].getUnderlying());
59. }
60. // 更新size=2的事件，将name改为'update1'
61. System.out.println("\nUpdate SelectEvent(size = 2) in SelectWindow!");
62. EPOnDemandQueryResult updateResult = epService.getEPRuntime().executeQuery(update);
63. events = updateResult.getArray();
64. for (int i = 0; i < events.length; i++) {
65. System.out.println(events[i].getUnderlying());
66. }
67. System.out.println("\nSelect SelectWindow!");
68. selectResult = epService.getEPRuntime().executeQuery(select);
69. events = selectResult.getArray();
70. for (int i = 0; i < events.length; i++) {
71. System.out.println(events[i].getUnderlying());
72. }
73. // 删除size<2的事件
74. System.out.println("\nDelete SelectEvent(size < 2) in SelectWindow!");
75. EPOnDemandQueryResult deleteResult = epService.getEPRuntime().executeQuery(delete);
76. events = deleteResult.getArray();
77. for (int i = 0; i < events.length; i++) {
78. System.out.println(events[i].getUnderlying());
79. }
80. System.out.println("\nSelect SelectWindow!");
81. selectResult = epService.getEPRuntime().executeQuery(select);
82. events = selectResult.getArray();
83. for (int i = 0; i < events.length; i++) {
84. System.out.println(events[i].getUnderlying());
85. }
86. }
87. }

执行结果：

1. Send SelectEvent 1: name=se1, size=1
2. Send SelectEvent 2: name=se2, size=2
3. Select SelectWindow!
4. name=se1, size=1
5. name=se2, size=2
6. Update SelectEvent(size = 2) in SelectWindow!
7. name=update1, size=2
8. Select SelectWindow!
9. name=se1, size=1
10. name=update1, size=2
11. Delete SelectEvent(size < 2) in SelectWindow!
12. name=se1, size=1
13. Select SelectWindow!
14. name=update1, size=2

 

10.Explicitly Indexing Named Windows

因为named window中可以存放事件，所以对存有大量的事件的window进行操作时，效率肯定是一个很大的问题。因此Esper支持对named window建立索引，具体来说是对named window中存放的事件的属性建立索引。我没有实际测试过加过索引之后操作时间有没有缩短，所以如果有人测试过并的确有好效果，希望能在本篇评论里向我反馈下，谢谢。
语法如下：

1. create [unique] index index_name on named_window_name (property [hash| btree] [, property] [hash|btree] [,...] )

unique代表建立唯一索引，如果插入了重复的行，则会抛出异常并阻止重复行插入。如果不使用此关键字，则表示可以插入重复行。index_name为索引的名称，named_window_name是要建立索引的named window。
后面的括号中包含named window中的属性以及索引类型。索引类型分两种，hash索引不会排序，如果有=操作，建议使用此类型索引。btree索引基于排序二叉树，适合<, >, >=, <=, between, in等操作。如果不显式声明hash或者btree，则默认为hash索引。举例如下：

1. // create a unique index on user id（hash） and profile id（hash）
2. create unique index UserProfileIndex on UserProfileWindow(userId, profileId)
3. // create a non-unique index on symbol（hash） and buyPrice（btree）
4. create index idx1 on TickEventWindow(symbol hash, buyPrice btree)

11.Dropping or Removing Named Windows

注销named window的方式是直接调用EPStatement对象的destroy方法。虽然注销，但是named window的名字仍然被占用着，所以你只能重新建立和之前的named window一样结构的window，否则会抛出异常。例如：

1. // Create DropWindow
2. create window DropWindow.win:keepall() as select * from DropEvent
3. // Destroy DropWindow
4. EPStatement state = admin.createEPL("create window DropWindow.win:keepall() as select * from DropEvent");
5. state.destroy();
6. // Create DropEvent again(different with prior epl)
7. create window DropWindow.win:keepall() as select name from DropEvent
8. // throw Exception