距离上一篇博客已经有很多个月的时间了,由于工作的原因,没怎么腾出手来写博客。再加上自己已计划算法学习为第一要务,更新博客的事情暂时就放缓了脚步。所以各位童鞋大可不必等我的博客,先把文档看起来,有什么不懂的先记下来,可以私信问我也可以等文章出来后再理解一遍,这样就不耽误大家的学习了。

上一篇我们说到了named window,这在Esper中是一个核心内容,基本上真实的业务场景下都会用到这东西,所以篇幅也较长,希望大家能消化好。今天这篇主要讨论的内容不复杂,都是几个小知识点,各位在之后的应用中也会用得到。

1. Splitting and Duplicating Streams

在之前我们学过的内容中有一个insert into的语法,作用是将某个epl生成的事件流输入到另外的事件中,以方便再次对数据进行处理。当然我也可以将事件流不进行处理就输出到下一个事件流中,使同一个事件流能够交给不同的epl进行处理。但是你会发现这样写起来比较麻烦,每一个insert into是一个句子,引擎要分别对他们进行注册,这样管理起来并不太容易。这一节的内容讲的就是一种简便的方法来达到将同一个事件流分发到不同的事件流中,且他是以一个句子就可以完成的。语法如下:

  1. [context context_name]
  2. on event_type[(filter_criteria)] [as stream_name]
  3. insert into insert_into_def select select_list [where condition]
  4. [insert into insert_into_def select select_list [where condition]]
  5. [insert into...]
  6. [output first | all]

第一行就不多说了,第二行为触发下面一系列操作的基础事件,也是基础事件流。event_type之后可以跟着过滤条件以及对事件流增加别名。第三行到第五行都是具体的insert句子,多个句子不需要用符号隔开,空格分离就好了。这里面的insert句子和之前学习的没区别,主要就是包含输入到什么事件流要写清楚,以及select的具体内容,where条件为可选。最后一行也是可选内容,output first表示从第一个insert句子开始到最后一个,基础事件依次匹配其where条件,只要满足了某一个,那么插入到对应的事件流以后,这个基础事件就不再有机会和之后的where进行匹配,即不会再进入之后的事件流中。而output all则表示基础事件和所有的insert句子的where进行匹配,能满足的就进入对应的事件流,即不会像first那样限制基础事件只能被输入到某一个流中。注意:select子句和where子句不能用聚合函数(这一点我觉得有点不爽,本来这个语法就是方便做事件分流的,不能用聚合函数的话就显得高不成低不就了)。下面我给大家一个完整的例子进行说明:

  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/26/14.
  11. */
  12. class SplitEvent implements Serializable {
  13. private int size;
  14. private int price;
  15. public SplitEvent(int price, int size) {
  16. this.price = price;
  17. this.size = size;
  18. }
  19. public int getPrice() {
  20. return price;
  21. }
  22. public void setPrice(int price) {
  23. this.price = price;
  24. }
  25. public int getSize() {
  26. return size;
  27. }
  28. public void setSize(int size) {
  29. this.size = size;
  30. }
  31. public String toString() {
  32. return "SplitEvent{" + "size=" + size + ", price=" + price + '}';
  33. }
  34. }
  35. public class SplitDuplicateTest {
  36. public static void main(String[] args) {
  37. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
  38. EPAdministrator admin = epService.getEPAdministrator();
  39. EPRuntime runtime = epService.getEPRuntime();
  40. String splitEvent = SplitEvent.class.getName();
  41. String epl1 = "create window LargeOrder.win:keepall() (price int) ";
  42. String epl2 = "create window MediumOrder.win:keepall() (price int)";
  43. String epl3 = "create window SmallOrder.win:keepall() (price int)";
  44. String epl4 = "create window LargeSize.win:keepall() (size int)";
  45. String epl5 = "create window MediumSize.win:keepall() (size int)";
  46. String epl6 = "create window SmallSize.win:keepall() (size int)";
  47. // output first
  48. String insert1 = "insert into LargeOrder select price where price > 8";
  49. String insert2 = "insert into MediumOrder select price where price between 3 and 10";
  50. String insert3 = "insert into SmallOrder select price where price <= 3";
  51. String epl7 = "on " + splitEvent + " " + insert1 + " " + insert2 + " " + insert3;
  52. // output all
  53. String insert4 = "insert into LargeSize select size where size > 5";
  54. String insert5 = "insert into MediumSize select size where size between 2 and 8";
  55. String insert6 = "insert into SmallSize select size where size <= 2";
  56. String epl8 = "on " + splitEvent + " " + insert4 + " " + insert5 + " " + insert6 + " output all";
  57. System.out.println("Output first(default): ");
  58. System.out.println(insert1);
  59. System.out.println(insert2);
  60. System.out.println(insert3);
  61. System.out.println();
  62. System.out.println("Output all: ");
  63. System.out.println(insert4);
  64. System.out.println(insert5);
  65. System.out.println(insert6);
  66. String selectLargeOrder = "select * from LargeOrder";
  67. String selectMediumOrder = "select * from MediumOrder";
  68. String selectSmallOrder = "select * from SmallOrder";
  69. String selectLargeSize = "select * from LargeSize";
  70. String selectMediumSize = "select * from MediumSize";
  71. String selectSmallSize = "select * from SmallSize";
  72. System.out.println();
  73. admin.createEPL(epl1);
  74. admin.createEPL(epl2);
  75. admin.createEPL(epl3);
  76. admin.createEPL(epl4);
  77. admin.createEPL(epl5);
  78. admin.createEPL(epl6);
  79. admin.createEPL(epl7);
  80. admin.createEPL(epl8);
  81. SplitEvent se1 = new SplitEvent(1, 2);
  82. SplitEvent se2 = new SplitEvent(9, 4);
  83. SplitEvent se3 = new SplitEvent(3, 1);
  84. SplitEvent se4 = new SplitEvent(5, 6);
  85. SplitEvent se5 = new SplitEvent(7, 9);
  86. System.out.println(se1);
  87. runtime.sendEvent(se1);
  88. System.out.println(se2);
  89. runtime.sendEvent(se2);
  90. System.out.println(se3);
  91. runtime.sendEvent(se3);
  92. System.out.println(se4);
  93. runtime.sendEvent(se4);
  94. System.out.println(se5);
  95. runtime.sendEvent(se5);
  96. EPOnDemandQueryResult selectLOrder = runtime.executeQuery(selectLargeOrder);
  97. EPOnDemandQueryResult selectMOrder = runtime.executeQuery(selectMediumOrder);
  98. EPOnDemandQueryResult selectSOrder = runtime.executeQuery(selectSmallOrder);
  99. EPOnDemandQueryResult selectLSize = runtime.executeQuery(selectLargeSize);
  100. EPOnDemandQueryResult selectMSize = runtime.executeQuery(selectMediumSize);
  101. EPOnDemandQueryResult selectSSize = runtime.executeQuery(selectSmallSize);
  102. outputResult(selectLargeOrder, selectLOrder);
  103. outputResult(selectMediumOrder, selectMOrder);
  104. outputResult(selectSmallOrder, selectSOrder);
  105. outputResult(selectLargeSize, selectLSize);
  106. outputResult(selectMediumSize, selectMSize);
  107. outputResult(selectSmallSize, selectSSize);
  108. }
  109. private static void outputResult(String selectSentence, EPOnDemandQueryResult result) {
  110. System.out.println("\n" + selectSentence);
  111. EventBean[] events = result.getArray();
  112. for (int i = 0; i < events.length; i++) {
  113. EventBean event = events[i];
  114. System.out.println(event.getUnderlying());
  115. }
  116. }
  117. }

执行结果:

  1. Output first(default):
  2. insert into LargeOrder select price where price > 8
  3. insert into MediumOrder select price where price between 3 and 10
  4. insert into SmallOrder select price where price <= 3
  5. Output all:
  6. insert into LargeSize select size where size > 5
  7. insert into MediumSize select size where size between 2 and 8
  8. insert into SmallSize select size where size <= 2
  9. SplitEvent{size=6, price=5}
  10. SplitEvent{size=2, price=1}
  11. SplitEvent{size=4, price=9}
  12. SplitEvent{size=1, price=3}
  13. SplitEvent{size=9, price=7}
  14. select * from LargeOrder
  15. {price=9}
  16. select * from MediumOrder
  17. {price=3}
  18. {price=5}
  19. {price=7}
  20. select * from SmallOrder
  21. {price=1}
  22. select * from LargeSize
  23. {size=6}
  24. {size=9}
  25. select * from MediumSize
  26. {size=2}
  27. {size=4}
  28. {size=6}
  29. select * from SmallSize
  30. {size=2}
  31. {size=1}

从上面的例子中可以看出,在默认情况下,也就是output first的时候,price=9进入LargeOrder后就不再进入MediumOrder,即使9是大于3小于10。

2. Variables and Constants

变量和常量在各类计算机语言中我相信大家都不陌生,在Esper同样有这个定义,并且用途广泛。比如说:时间、过滤条件等等,可以用于各种计算表达式。变量和常量都可以通过三种方式建立:API、EPL、配置文件。各有各的优点,这一节只讲前两种创建方式,配置文件后面会有专门的章节进行讲解。

调用API创建变量和常量:

  1. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
  2. EPAdministrator admin = epService.getEPAdministrator();
  3. ConfigurationOperations conf = admin.getConfiguration();
  4. conf.addVariable("abc", String.class, "initVariable");
  5. conf.addVariable("constabc", int.class.getName(), 123, true);
  6. ... equals ...
  7. Configuration conf = new Configuration();
  8. conf.addVariable("abc", String.class, "initVariable");
  9. conf.addVariable("constabc", int.class.getName(), 123, true);
  10. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider(conf);

可以看到,调用API也有两种方式,一种是建立了EPAdministrator之后再设置变量及常量,一种是先配置好变量及常量,再生成epSerivce对象。两种各有好处,大家自己斟酌。

用EPL创建变量和常量:

  1. create [constant] variable variable_type [[]]variable_name [ = assignment_expression ]

constant为可选关键字,显式声明则表示声明的是常量,否则声明的是变量。variable_type和variable_name分别表示变量的数据类型和变量名,变量名必须唯一。variable_type之后的[]表示这是一个数组类型的变量。之后的assignment_expression为该变量的初始值,如果不声明则表示没有初始值。下面的列表是可声明的变量类型:

string\char\character\bool\boolean\byte\short\int\integer\long\double\float\object\enum_class\class_name\event_type_name

下面举几个例子来看看:

  1. // 创建一个long类型的变量,没有初始值
  2. create variable long var_threshold
  3. // 创建一个integer类型的变量,初始值为10
  4. create variable integer var_output_rate = 10
  5. // 创建一个object类型的变量,没有初始值(使用时需要转换成对应的对象类型)
  6. create variable object varobj
  7. // 创建一个PageHitEvent事件类型的变量,没有初始值(在此之前需要导入这个事件类型到引擎)
  8. create variable PageHitEvent varPageHitZero
  9. // 创建一个OrderEvent事件类型的变量,没有初始值(可以直接使用类全名作为事件类型)
  10. create variable com.abc.OrderEvent orderEvent
  11. // 创建一个string类型的常量,初始值为'GE'
  12. create constant variable string const_filter_symbol = 'GE'
  13. // 创建一个string数组类型的常量,初始值为{'GE', 'MSFT'}
  14. create constant variable string[] const_filters = {'GE', 'MSFT'}
  15. // 创建一个enumeration数组类型的常量,初始值为{Color.RED, Color.BLUE}
  16. create constant variable Color[] const_colors = {Color.RED, Color.BLUE}

常量创建后自然是不能修改的,但是变量肯定是可以改变的。语法如下:

  1. on event_type[(filter_criteria)] [as stream_name]
  2. set variable_name = expression [, variable_name = expression [,...]]

简单来说就是通过接收某类事件并加上一定的过滤条件,就能够将变量重新赋值,并且可以同时为多个变量赋值。举例如下:

  1. on NewOutputRateEvent set var_output_rate = rate
  2. on ThresholdUpdateEvent as t set var_threshold_lower = t.lower, var_threshold_higher = t.higher

3. Contained-Event Selection

这一节讲解的查询语法比较特殊,该语法主要是针对某个事件的属性仍是事件的一种查询方式。很多人都有把它翻译成中文的习惯,比如:容器事件查询,又或者查询容器事件。啥叫容器事件?反正我是翻译不出来,而且我也建议的大家不要翻译,以免在学习的过程中对不上,只要理解这个词的概念就行了。下面我们先用最简单的select-from子句进行讲解。语法如下:

  1. [select select_expressions from]
  2. contained_expression [@type(eventtype_name)]
  3. [as alias_name] [where filter_expression]

方括号里的东西是可选的,并且大部分大家应该都很熟悉,除了那个@type,这个我们之后再讲。该语法的重点在于contained_expression,这个表达式需要返回事件的属性,该属性可以是另一个事件也可以是普通数据类型,也可以是一组查询结果,比如一个数组,一个集合等等。官方文档的5.20节有一个xml的例子,下面的示例我将以此作为基础。并且由于在之前我没有讲解xml作为事件是如何处理的,所以特地将xml转换成了对应的POJO进行测试,方便各位理解。

基础事件定义:

  1. public class Item {
  2. private int itemId;
  3. private int productId;
  4. private int amount;
  5. private double price;
  6. // getter and setter method...
  7. public String toString() {
  8. return "Item{" + "itemId=" + itemId + ", productId=" + productId + ", amount=" + amount + ", price=" + price + '}';
  9. }
  10. }
  11. public class Items {
  12. private List<Item> item;
  13. // getter and setter method...
  14. }
  15. public class Review {
  16. private int reviewId;
  17. private String comment;
  18. // getter and setter method...
  19. public String toString() {
  20. return "Review{" + "reviewId=" + reviewId + ", comment='" + comment + '\'' + '}';
  21. }
  22. }
  23. public class Book {
  24. private int bookId;
  25. private String author;
  26. private Review review;
  27. // getter and setter method...
  28. public String toString() {
  29. return "Book{" + "bookId=" + bookId + ", author='" + author + '\'' + ", review=" + review + '}';
  30. }
  31. }
  32. public class Books {
  33. private List<Book> book;
  34. // getter and setter method...
  35. }
  36. public class MediaOrder {
  37. private int orderId;
  38. private Items items;
  39. private Books books;
  40. // getter and setter method...
  41. public String toString() {
  42. return "MediaOrder{" + "orderId=" + orderId + ", items=" + items + ", books=" + books + '}';
  43. }
  44. }

主类:

  1. class SelectContainedListener implements UpdateListener {
  2. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
  3. if (newEvents != null) {
  4. for (int i = 0; i < newEvents.length; i++) {
  5. if (newEvents[i] == null) {
  6. continue;
  7. }
  8. System.out.println(newEvents[i].getUnderlying());
  9. }
  10. }
  11. }
  12. }
  13. public class SelectContainedEventTest {
  14. public static void main(String[] args) {
  15. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
  16. EPAdministrator admin = epService.getEPAdministrator();
  17. EPRuntime runtime = epService.getEPRuntime();
  18. Review r1 = new Review();
  19. r1.setReviewId(1);
  20. r1.setComment("r1");
  21. Book b1 = new Book();
  22. b1.setAuthor("b1");
  23. b1.setBookId(1);
  24. b1.setReview(r1);
  25. Book b2 = new Book();
  26. b2.setAuthor("b2");
  27. b2.setBookId(2);
  28. Item i1 = new Item();
  29. i1.setItemId(1);
  30. i1.setProductId(1);
  31. i1.setPrice(1.11);
  32. i1.setAmount(2);
  33. MediaOrder mo1 = new MediaOrder();
  34. Books bs = new Books();
  35. Items is = new Items();
  36. List<Item> items = new ArrayList<Item>();
  37. List<Book> books = new ArrayList<Book>();
  38. items.add(i1);
  39. books.add(b1);
  40. books.add(b2);
  41. mo1.setOrderId(1);
  42. bs.setBook(books);
  43. is.setItem(items);
  44. mo1.setItems(is);
  45. mo1.setBooks(bs);
  46. String mediaOrder = MediaOrder.class.getName();
  47. String epl = "select * from " + mediaOrder + "[books.book]";
  48. EPStatement stat1 = admin.createEPL(epl);
  49. stat1.addListener(new SelectContainedListener());
  50. runtime.sendEvent(mo1);
  51. }
  52. }

输出结果:

  1. Book{bookId=1, author='b1', review=Review{reviewId=1, comment='r1'}}
  2. Book{bookId=2, author='b2', review=null}

例子很简单,就是将Books中的Book筛选出来。再进一步,如果只想把Review筛选出来,句子应该这么写:

  1. select * from MediaOrder[books.book][review]
  2. // not valid
  3. select * from MediaOrder[books.book.review]

第二种写法错误是因为books.book返回的是一个Book对象的数组,数组自然是不会包含Review属性的。所以改成下面这样就可以了:

select * from MediaOrder[books.book[1].review] // 取Book数组中下标为1的对象的review属性

 

3.1 Select Clause in a Contained-Event Selection

上面的几个例子都是查出某个对象的所有属性,比如Book和Review。如果要查部分属性,则需要select子句的帮助,也就是之前说的可选部分[select select_expressions from]

还是上面的数据,我们写几个句子看看:

  1. // 查询bookId,orderId
  2. 1)select * from MediaOrder[select bookId, orderId from books.book][review]
  3. ... equals ...
  4. 2)select * from MediaOrder[books.book][select bookId, orderId from review]
  5. // not valid
  6. 3)select * from MediaOrder[select bookId, orderId, reviewId from books.book][review]
  7. // valid 查询bookId,orderId,reviewId
  8. 4)select * from MediaOrder[books.book][select bookId, orderId, reviewId from review]

大家可能会有疑问,为什么1)中orderId是来自books.book?又为什么3)的这种写法不对?既然orderId可以,reviewId不可以?文档中对这点没有任何的说明,相当于是一种固定语法了。但是细想一下,orderId和book都是MediaOrder的属性并且是同级的。所以我个人认为(纯属猜想),从语法分析的角度考虑,同一级别的属性,不会只能解析出book而不会找不到orderId。因此3)中,由于reviewId是book的review属性的属性,所以只能来自review,没法跳过review,直接从book中获得。

1)和2)中的select子句只有bookId和orderId,所以1)最后的[review]实际上没有什么用,除非你写成这样:select * from MediaOrder[select bookId, orderId from books.book][select * from review]。得出的就是bookId,orderId以及Review对象的所有属性。

在使用上面的语法时,要注意子查询,聚合函数等不能用在contained-event的select子句中。

3.2 Where Clause in a Contained-Event Selection

除了可以在Contained-Event上用select子句,同样也可以用where子句,比如:

  1. // 查询author是luonanqin的book
  2. select * from MediaOrder[books.book where author = 'luonanqin']
  3. // 查询comment中包含good字符串的review
  4. select * from MediaOrder[books.book][review where comment like 'good']

3.3 Contained-Event Selection and Joins

Contained-Event除了一些普通的用法之外,还可以使用在join查询中。包括内联、左联、右联以及全外连接。由于用法简单,所以我直接给了一个完整的例子。POJO类仍然利用上面的定义不变。

  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 example.model.contained.Book;
  10. import example.model.contained.Books;
  11. import example.model.contained.Item;
  12. import example.model.contained.Items;
  13. import example.model.contained.MediaOrder;
  14. import example.model.contained.Review;
  15. import java.util.ArrayList;
  16. import java.util.List;
  17. /**
  18. * Created by Luonanqin on 7/30/14.
  19. */
  20. class JoinContainedListener implements UpdateListener {
  21. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
  22. if (newEvents != null) {
  23. for (int i = 0; i < newEvents.length; i++) {
  24. if (newEvents[i] == null) {
  25. continue;
  26. }
  27. System.out.println(newEvents[i].getUnderlying());
  28. }
  29. }
  30. }
  31. }
  32. public class JoinContainedEventTest {
  33. public static void main(String[] args) {
  34. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
  35. EPAdministrator admin = epService.getEPAdministrator();
  36. EPRuntime runtime = epService.getEPRuntime();
  37. Review r1 = new Review();
  38. r1.setReviewId(1);
  39. r1.setComment("r1");
  40. Book b1 = new Book();
  41. b1.setAuthor("b1");
  42. b1.setBookId(1);
  43. b1.setReview(r1);
  44. Book b2 = new Book();
  45. b2.setAuthor("b2");
  46. b2.setBookId(2);
  47. b2.setReview(new Review());
  48. Item i1 = new Item();
  49. i1.setItemId(1);
  50. i1.setProductId(1);
  51. i1.setPrice(1.11);
  52. i1.setAmount(2);
  53. Item i2 = new Item();
  54. i2.setItemId(3);
  55. i2.setProductId(3);
  56. i2.setPrice(3.11);
  57. i2.setAmount(5);
  58. MediaOrder mo1 = new MediaOrder();
  59. Books bs = new Books();
  60. Items is = new Items();
  61. List<Item> items = new ArrayList<Item>();
  62. List<Book> books = new ArrayList<Book>();
  63. items.add(i1);
  64. items.add(i2);
  65. books.add(b1);
  66. books.add(b2);
  67. mo1.setOrderId(1);
  68. bs.setBook(books);
  69. is.setItem(items);
  70. mo1.setItems(is);
  71. mo1.setBooks(bs);
  72. String mediaOrder = MediaOrder.class.getName();
  73. String join1 = "select book.bookId, item.itemId from " + mediaOrder + "[books.book] as book, " + mediaOrder
  74. + "[items.item] as item where productId = bookId";
  75. EPStatement stat1 = admin.createEPL(join1);
  76. stat1.addListener(new JoinContainedListener());
  77. System.out.println("EPL1: " + join1);
  78. runtime.sendEvent(mo1);
  79. stat1.destroy();
  80. System.out.println();
  81. String join2 = "select book.bookId, item.itemId from " + mediaOrder + "[books.book] as book left outer join " + mediaOrder
  82. + "[items.item] as item on productId = bookId";
  83. EPStatement stat2 = admin.createEPL(join2);
  84. stat2.addListener(new JoinContainedListener());
  85. System.out.println("EPL2: " + join2);
  86. runtime.sendEvent(mo1);
  87. stat2.destroy();
  88. System.out.println();
  89. String join3 = "select book.bookId, item.itemId from " + mediaOrder + "[books.book] as book full outer join " + mediaOrder
  90. + "[items.item] as item on productId = bookId";
  91. EPStatement stat3 = admin.createEPL(join3);
  92. stat3.addListener(new JoinContainedListener());
  93. System.out.println("EPL3: " + join3);
  94. runtime.sendEvent(mo1);
  95. stat3.destroy();
  96. System.out.println();
  97. String join4 = "select count(*) from " + mediaOrder + "[books.book] as book, " + mediaOrder
  98. + "[items.item] as item where productId = bookId";
  99. EPStatement stat4 = admin.createEPL(join4);
  100. stat4.addListener(new JoinContainedListener());
  101. System.out.println("EPL4: " + join4);
  102. runtime.sendEvent(mo1);
  103. runtime.sendEvent(mo1);
  104. stat4.destroy();
  105. System.out.println();
  106. String join5 = "select count(*) from " + mediaOrder + "[books.book] as book unidirectional, " + mediaOrder
  107. + "[items.item] as item where productId = bookId";
  108. EPStatement stat5 = admin.createEPL(join5);
  109. stat5.addListener(new JoinContainedListener());
  110. System.out.println("EPL5: " + join5);
  111. runtime.sendEvent(mo1);
  112. runtime.sendEvent(mo1);
  113. stat5.destroy();
  114. System.out.println();
  115. }
  116. }

执行结果:

  1. EPL1: select book.bookId, item.itemId from example.model.contained.MediaOrder[books.book] as book, example.model.contained.MediaOrder[items.item] as item where productId = bookId
  2. {item.itemId=1, book.bookId=1}
  3. EPL2: select book.bookId, item.itemId from example.model.contained.MediaOrder[books.book] as book left outer join example.model.contained.MediaOrder[items.item] as item on productId = bookId
  4. {item.itemId=1, book.bookId=1}
  5. {item.itemId=null, book.bookId=2}
  6. EPL3: select book.bookId, item.itemId from example.model.contained.MediaOrder[books.book] as book full outer join example.model.contained.MediaOrder[items.item] as item on productId = bookId
  7. {item.itemId=1, book.bookId=1}
  8. {item.itemId=null, book.bookId=2}
  9. {item.itemId=3, book.bookId=null}
  10. EPL4: select count(*) from example.model.contained.MediaOrder[books.book] as book, example.model.contained.MediaOrder[items.item] as item where productId = bookId
  11. {count(*)=1}
  12. {count(*)=2}
  13. EPL5: select count(*) from example.model.contained.MediaOrder[books.book] as book unidirectional, example.model.contained.MediaOrder[items.item] as item where productId = bookId
  14. {count(*)=1}
  15. {count(*)=1}

前三个例子应该非常好理解,和普通连接操作没太大区别。4和5的区别在于unidirectional,4中不包含这个关键字时,发送两个同样的mediaOrder对象,聚合函数count是要累加的,而5有了这个关键字后,就将每次连接操作的结果都独立起来了。但是有一点要记住:如果Contained-Event来自于named window,那么连接操作就必须加上unidirectional关键字

上面的三小节基本上就是Contained-Event的全部内容,官方文档上还有别的例子可以看看。不过说实话本人其实也没用过,但是存在即合理,所以咱们暂且先学习着,以后肯定能用到。

4. Updating an Insert Stream

在之前讲解基础语法的时候,大家都接触了select、insert into、on delete、on update等操作,并且后两个是针对named window的。那有没有单独的update语法呢?有!为什么放到这一节才讲呢?我其实也是跟着文档来进行总结的,简直就是坑货嘛。今天先教大家,改日有空了我再移到前面和基础语法放到一起。

多说了几句废话。。。update语法简单,意义也简单,就是在事件即将被用于计算前,改变其自身的属性值,然后再将其用于后面的计算。语法如下:

  1. update istream event_type [as stream_name]
  2. set property_name = set_expression [, property_name = set_expression] [,...]
  3. [where where_expression]

istream表明更新的是新输入的事件(但是没有rstream,不知道这里为啥要指明这个关键字。。),event_type代表要更新的事件,set之后的property_name是要更新的事件属性,最后可以用where子句进行简单的过滤。

因为事件会在计算前被更新,所以在事件还未到来之前,两类句子的创建顺序不管怎样都会使得update生效。但是如果有部分事件已经参与计算了,之后才创建update句子,那已经参与计算的事件就不会被更新了,之后的进入引擎的事件才会被更新。

上面说的是不同于update句子的创建顺序导致的不同结果。如果有多个update句子作用于同一类事件,那么先创建的会先更新事件。但是如果在update句首用@Priority这个注解,那么更新事件的顺序是以优先级最高的最先更新。所以我建议大家在同时使用多个update句子的时候,最好使用优先级,因为你很可能搞不清楚所有update句子的创建顺序。

针对以上两点,我提供了一个简单的例子供大家参考。

  1. package example;
  2. import com.espertech.esper.client.Configuration;
  3. import com.espertech.esper.client.EPAdministrator;
  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.EPStatement;
  8. import com.espertech.esper.client.EventBean;
  9. import com.espertech.esper.client.UpdateListener;
  10. import java.io.Serializable;
  11. /**
  12. * Created by Luonanqin on 7/31/14.
  13. */
  14. class UpdateEvent implements Serializable {
  15. private int id;
  16. private String name;
  17. public int getId() {
  18. return id;
  19. }
  20. public void setId(int id) {
  21. this.id = id;
  22. }
  23. public String getName() {
  24. return name;
  25. }
  26. public void setName(String name) {
  27. this.name = name;
  28. }
  29. public String toString() {
  30. return "UpdateEvent{" + "id=" + id + ", name='" + name + '\'' + '}';
  31. }
  32. }
  33. class UpdateEventListener implements UpdateListener {
  34. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
  35. if (newEvents != null) {
  36. for (int i = 0; i < newEvents.length; i++) {
  37. System.out.println("newEvent: " + newEvents[i].getUnderlying());
  38. }
  39. }
  40. if (oldEvents != null) {
  41. for (int i = 0; i < oldEvents.length; i++) {
  42. System.out.println("oldEvent: " + oldEvents[i].getUnderlying());
  43. }
  44. }
  45. }
  46. }
  47. public class UpdateEventTest {
  48. public static void main(String[] args) {
  49. /**
  50. * config:
  51. *
  52. * <engine-settings>
  53. *      <defaults>
  54. *          <execution prioritized="true"/>
  55. *      </defaults>
  56. *  </engine-settings>
  57. */
  58. Configuration config = new Configuration();
  59. config.configure("esper.examples.cfg.xml");
  60. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider(config);
  61. EPAdministrator admin = epService.getEPAdministrator();
  62. EPRuntime runtime = epService.getEPRuntime();
  63. UpdateEventListener listener = new UpdateEventListener();
  64. UpdateEvent ue = new UpdateEvent();
  65. ue.setId(1);
  66. ue.setName("luonanqin");
  67. UpdateEvent ue2 = new UpdateEvent();
  68. ue2.setId(2);
  69. ue2.setName("qinnanluo");
  70. String updateEvent = UpdateEvent.class.getName();
  71. String select = "select * from " + updateEvent;
  72. String update1 = "@Priority(2)update istream " + updateEvent + " set name='qnoul' where id = 1";
  73. String update2 = "@Priority(1)update istream " + updateEvent + " set name='luonq' where id = 1";
  74. EPStatement stat1 = admin.createEPL(select);
  75. stat1.addListener(listener);
  76. System.out.println("select EPL: " + select);
  77. runtime.sendEvent(ue);
  78. runtime.sendEvent(ue2);
  79. System.out.println();
  80. EPStatement stat2 = admin.createEPL(update1);
  81. stat2.addListener(listener);
  82. System.out.println("update1 EPL: " + update1);
  83. runtime.sendEvent(ue);
  84. runtime.sendEvent(ue2);
  85. System.out.println();
  86. EPStatement stat3 = admin.createEPL(update2);
  87. stat3.addListener(listener);
  88. System.out.println("update2 EPL: " + update2);
  89. runtime.sendEvent(ue);
  90. runtime.sendEvent(ue2);
  91. }
  92. }

执行结果(注释是我自己添加的,不属于执行结果):

  1. select EPL: select * from example.UpdateEvent
  2. newEvent: UpdateEvent{id=1, name='luonanqin'}
  3. newEvent: UpdateEvent{id=2, name='qinnanluo'}
  4. update1 EPL: @Priority(2)update istream example.UpdateEvent set name='qnoul' where id = 1
  5. newEvent: UpdateEvent{id=1, name='qnoul'}       // update1 result
  6. oldEvent: UpdateEvent{id=1, name='luonanqin'}   // update1 result
  7. newEvent: UpdateEvent{id=1, name='qnoul'}       // select result
  8. newEvent: UpdateEvent{id=2, name='qinnanluo'}   // select result
  9. update2 EPL: @Priority(1)update istream example.UpdateEvent set name='luonq' where id = 1
  10. newEvent: UpdateEvent{id=1, name='luonq'}       // update2 result
  11. oldEvent: UpdateEvent{id=1, name='luonanqin'}   // update2 result
  12. newEvent: UpdateEvent{id=1, name='qnoul'}       // update1 result
  13. oldEvent: UpdateEvent{id=1, name='luonq'}       // update1 result
  14. newEvent: UpdateEvent{id=1, name='qnoul'}       // select result
  15. newEvent: UpdateEvent{id=2, name='qinnanluo'}   // select result

updateListener方法中,newEvents表示更新后的属性值,oldEvents表示更新前的属性值。

使用update语法有几点要注意:
1). 如果事件是POJO,那么要实现java.io.Serializable接口。因为引擎内部的update操作实际上是要先深复制原事件再更新拷贝后的事件,不会对原事件作出任何修改。
2). 设置属性的表达式不能用聚合函数
3). 如果事件是xml,update语法则不适用
4). update操作不可用于嵌套的事件

5. Controlling Event Delivery : The For Clause

大家应该都注意到在此之前我们的UpdateListener在达到触发条件时,都是只触发一次,并且把满足这次触发的所有事件传给update方法。Esper对此提供了一个比较另类的触发方式——可设置条件对Listener进行多次触发,也就是这节所讲的For子句。各位可别把这个For子句想成for循环了,根本就是两码事。

For子句可应用在所有的Select子句之后,并且分为两类触发。一个是根据分组条件进行多次触发,即每一组触发一次。另一个是一个事件触发一次。对应的语法如下:

  1. // 分组触发
  2. ... for grouped_delivery (group_expression [, group_expression] [,...])
  3. // 每个事件都触发
  4. ... for discrete_delivery

针对上面两类触发,我提供了一个简单的示例。

  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 7/31/14.
  11. */
  12. class ForEvent {
  13. private String name;
  14. private int age;
  15. public String getName() {
  16. return name;
  17. }
  18. public void setName(String name) {
  19. this.name = name;
  20. }
  21. public int getAge() {
  22. return age;
  23. }
  24. public void setAge(int age) {
  25. this.age = age;
  26. }
  27. public String toString() {
  28. return "ForEvent{" + "name='" + name + '\'' + ", age=" + age + '}';
  29. }
  30. }
  31. class ForListener implements UpdateListener {
  32. // 用于记录调用次数
  33. private int num = 1;
  34. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
  35. System.out.println("invocation: " + num++);
  36. if (newEvents != null) {
  37. for (int i = 0; i < newEvents.length; i++) {
  38. System.out.println(newEvents[i].getUnderlying());
  39. }
  40. }
  41. }
  42. }
  43. public class ForTest {
  44. public static void main(String[] args) {
  45. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
  46. EPAdministrator admin = epService.getEPAdministrator();
  47. EPRuntime runtime = epService.getEPRuntime();
  48. String forEvent = ForEvent.class.getName();
  49. String select = "select * from " + forEvent + ".win:length_batch(3)";
  50. String for1 = "select * from " + forEvent + ".win:length_batch(3) for grouped_delivery (age)";
  51. String for2 = "select * from " + forEvent + ".win:length_batch(3) for discrete_delivery";
  52. ForEvent fe1 = new ForEvent();
  53. fe1.setName("luo");
  54. fe1.setAge(1);
  55. ForEvent fe2 = new ForEvent();
  56. fe2.setName("nan");
  57. fe2.setAge(2);
  58. ForEvent fe3 = new ForEvent();
  59. fe3.setName("qin");
  60. fe3.setAge(1);
  61. EPStatement stat1 = admin.createEPL(select);
  62. stat1.addListener(new ForListener());
  63. System.out.println("select EPL1: " + select);
  64. System.out.println();
  65. runtime.sendEvent(fe1);
  66. runtime.sendEvent(fe2);
  67. runtime.sendEvent(fe3);
  68. stat1.destroy();
  69. System.out.println();
  70. EPStatement stat2 = admin.createEPL(for1);
  71. stat2.addListener(new ForListener());
  72. System.out.println("for EPL2: " + for1);
  73. System.out.println();
  74. runtime.sendEvent(fe1);
  75. runtime.sendEvent(fe2);
  76. runtime.sendEvent(fe3);
  77. stat2.destroy();
  78. System.out.println();
  79. EPStatement stat3 = admin.createEPL(for2);
  80. stat3.addListener(new ForListener());
  81. System.out.println("for EPL3: " + for2);
  82. System.out.println();
  83. runtime.sendEvent(fe1);
  84. runtime.sendEvent(fe2);
  85. runtime.sendEvent(fe3);
  86. }
  87. }

执行结果:

  1. select EPL1: select * from example.ForEvent.win:length_batch(3)
  2. invocation: 1
  3. ForEvent{name='luo', age=1}
  4. ForEvent{name='nan', age=2}
  5. ForEvent{name='qin', age=1}
  6. for EPL2: select * from example.ForEvent.win:length_batch(3) for grouped_delivery (age)
  7. invocation: 1
  8. ForEvent{name='luo', age=1}
  9. ForEvent{name='qin', age=1}
  10. invocation: 2
  11. ForEvent{name='nan', age=2}
  12. for EPL3: select * from example.ForEvent.win:length_batch(3) for discrete_delivery
  13. invocation: 1
  14. ForEvent{name='luo', age=1}
  15. invocation: 2
  16. ForEvent{name='nan', age=2}
  17. invocation: 3
  18. ForEvent{name='qin', age=1}

可以看到第二个For子句中的分组条件是age,所以只触发了两次。既然这样,下面这个句子有问题吗:

  1. select name from example.ForEvent.win:length_batch(3) for grouped_delivery (age)

select的内容是name,分组条件是age,Esper不允许这样做。这也是使用For子句时唯一要注意的地方,大家别忽略了。

Esper学习之十三:EPL语法(九)的更多相关文章

  1. Esper学习之七:EPL语法(三)

    1.Aggregation 和SQL一样,EPL也有Aggregation,即聚合函数.语法如下: aggregate_function([all|distinct] expression) aggr ...

  2. Esper学习之六:EPL语法(二)

    中秋三天,说闲也不闲,调调工作的代码,倒还解决不少问题.不过也是因为最近工作忙的缘故,Esper被我冷落不少日子了,趁着今天最后一天,赶紧写一篇出来. 从上一篇开始说EPL的语法,主要是关于注解的.今 ...

  3. Esper学习之五:EPL语法(一)

    上篇说到了Esper的Context,要是不了解的同学请参看<Esper学习之四:Context>,看过的同学如果还是不理解的话可以给我评论,我将会尽可能的解答.之前有些同学问我Conte ...

  4. Esper学习之八:EPL语法(四)

    关于EPL,已经写了三篇了,预估计了一下,除了今天这篇,后面还有5篇左右.大家可别嫌多,官方的文档对EPL的讲解有将近140页,我已经尽量将废话都干掉了,再配合我附上的例子,看我的10篇文章比那140 ...

  5. Esper学习之九:EPL语法(五)

    本篇的内容主要包括了Subquery(也就是子查询)和Join,内容不少,但是不难,基本上和sql差不太多. 1.Subquery EPL里的Subquery和sql的类似,是否比sql的用法更多我不 ...

  6. Esper学习之十二:EPL语法(八)

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

  7. Esper学习之十一:EPL语法(七)

    上一篇说到了EPL如何访问关系型数据库这种数据源,实际上别的数据源,比如:webservice.分布式缓存.非关系型数据库等等,Esper提供了统一的数据访问接口.然后今天会讲解如何创建另外一种事件类 ...

  8. Esper学习之四:Context

    上周末打球实在太累了,就没来得及更新,只是列了个提纲做做准备,发现Context还是有很多内容的.结果也花了不少时间才写完,所以这篇需要各位慢慢消化,并且最好多写几个例子加深理解. 如果有不了解Esp ...

  9. Esper学习之三:进程模型

    之前对Esper所能处理的事件结构进行了概述,并结合了例子进行讲解,不清楚的同学请看Esper学习之二:事件类型.今天主要为大家解释一下Esper是怎么处理事件的,即Esper的进程模型. 1.Upd ...

随机推荐

  1. CI框架 -- 核心文件 之 Benchmark.php

    Benchmark.php文件中定义的CI_Benchmark类可以让你标记点,并计算它们之间的时间差.还可以显示内存消耗. Benchmarking类库,它是被系统自动被加载的,不需要手工加载 cl ...

  2. Android 开源动画框架:NineOldAndroids

    介绍 Android 平台提供两种动画系统:Property Animation(Android 3.0引入)和View Animation.这两种动画都可供选择,但是Property Animati ...

  3. 非常酷的CSS3垂直下拉动画菜单

    昨天我向大家介绍了一款兼容性不错的jQuery淡入淡出下拉菜单,今天要分享一款相对绚丽的CSS3垂直下拉动画菜单,不过需要支持CSS3的浏览器才能有效果.下面是效果图,一起看看. 我们也可以在这里查看 ...

  4. Linux-centos6.8下关闭防火墙

    一.临时关闭防火墙 1. 查看防火墙的状态 [root@vpnSS ~]# /etc/init.d/iptables status Table: filter Chain INPUT (policy ...

  5. cocos2d - CCSprite各种动画

    转自 ITeye技术网站 // 触摸屏 -(void) ccTouchesEnded:(NSSet *)touches withEvent:(UIEvent *)event { for( UITouc ...

  6. PHP安全之临时文件的安全

    (一)临时文件简介临时文件,顾名思义是临时的文件,文件的生命周期短.然而,很多应用的运行都离不开临时文件,临时文件在我们电脑上无处不在,通常有以下几种形式的临时文件: 文件或图形编辑程序,所生成的中间 ...

  7. DIV背景图片定位问题

    <div class="custom-topNavigation_shadow"> </div>   正确写法 .custom-topNavigation_ ...

  8. iOS模拟(糟糕的)网络环境

    有时候为了模拟在糟糕的网络环境下app的表现,会故意拔网线(断wifi),苹果其实提供了专门的工具来精确地模拟你在几个预设的场景下的网络连接情况:Network Link Conditioner 点击 ...

  9. phpstorm 初体验

    最近在学php,今天想要读一下公司刚外包网站的源代码,要安装一个php的集成环境,因最开始用过JetBrains的pycharm觉得很好用,这会儿还选用该家产品PHPStorm(为啥storm这个词, ...

  10. 英文版Ubuntu18.10安装搜狗输入法过程(图文并茂,亲自尝试!)

    英文版Ubuntu18.10安装搜狗输入法过程 过程比较艰辛,折腾了好长的时间,不过最终还是装好了,特记录一下! 首先去搜狗输入法网址下载Linux版本:https://pinyin.sogou.co ...