public void testAfterNextRow() {
    Configuration config = SupportConfigFactory.getConfiguration();
    config.addEventType("MyEvent", SupportRecogBean.class);
    EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider(config);
    epService.initialize();

    String[] fields = "a,b0,b1".split(",");
    String text =
        "select * from MyEvent.win:keepall() "
            + "match_recognize ("
            + "  measures A.theString as a, B[0].theString as b0, B[1].theString as b1"
            + "  AFTER MATCH SKIP TO NEXT ROW "
            + "  pattern (A B*) "
            + "  define "
            + "    A as A.theString like 'A%',"
            + "    B as B.theString like 'B%'"
            + ")";

    EPStatement stmt = epService.getEPAdministrator().createEPL(text);
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportRecogBean("A1", 1));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"A1", null, null}});
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"A1", null, null}});

    // since the first match skipped past A, we do not match again
    epService.getEPRuntime().sendEvent(new SupportRecogBean("B1", 2));
    assertFalse(listener.isInvoked()); // incremental skips to next
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"A1", "B1", null}});
  }
Esempio n. 2
0
  private void configureImport() {
    // the single-row functions to be called are in this class
    provider.getEPAdministrator().getConfiguration().addImport(this.getClass());

    // Add an event type that has a byte-type property value
    Map<String, Object> typeDefinition = new HashMap<String, Object>();
    typeDefinition.put("byteValue", byte.class);
    provider.getEPAdministrator().getConfiguration().addEventType("MyByteEvent", typeDefinition);

    // keep the last few events from the variant stream
    EPStatement stmt =
        provider
            .getEPAdministrator()
            .createEPL(
                "select RuntimeConfigMain.check2BitSet(byteValue) as check2BitSet from MyByteEvent");

    // send an event
    Map<String, Object> eventData = new HashMap<String, Object>();
    eventData.put("byteValue", 2);
    provider.getEPRuntime().sendEvent(eventData, "MyByteEvent");

    // print results
    System.out.println("\nConfigure Import:");
    System.out.println("Received:" + " check2BitSet=" + stmt.iterator().next().get("check2BitSet"));

    // send a second event
    eventData = new HashMap<String, Object>();
    eventData.put("byteValue", 1);
    provider.getEPRuntime().sendEvent(eventData, "MyByteEvent");

    // print results
    System.out.println("Received:" + " check2BitSet=" + stmt.iterator().next().get("check2BitSet"));
  }
  private void runAssertion(
      EPServiceProvider epService, SupportUpdateListener listener, EPStatement stmt) {
    String[] fields = "a,b0,b1".split(",");

    epService.getEPRuntime().sendEvent(new SupportRecogBean("A1", 1));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"A1", null, null}});
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"A1", null, null}});

    // since the first match skipped past A, we do not match again
    epService.getEPRuntime().sendEvent(new SupportRecogBean("B1", 2));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"A1", "B1", null}});
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"A1", "B1", null}});
  }
  public void testObjectArrayNested() {
    EPServiceProvider epService = getEngineInitialized(null, null, null);
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("TypeLev1", new String[] {"p1id"}, new Object[] {int.class});
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType(
            "TypeLev0", new String[] {"p0id", "p1"}, new Object[] {int.class, "TypeLev1"});
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType(
            "TypeRoot", new String[] {"rootId", "p0"}, new Object[] {int.class, "TypeLev0"});

    EPStatement stmt =
        epService.getEPAdministrator().createEPL("select * from TypeRoot.std:lastevent()");
    Object[] dataLev1 = {1000};
    Object[] dataLev0 = {100, dataLev1};
    epService.getEPRuntime().sendEvent(new Object[] {10, dataLev0}, "TypeRoot");
    EventBean theEvent = stmt.iterator().next();
    EPAssertionUtil.assertProps(
        theEvent, "rootId,p0.p0id,p0.p1.p1id".split(","), new Object[] {10, 100, 1000});
  }
Esempio n. 5
0
  public void testJoinSelect() {
    String eventA = SupportBean.class.getName();
    String eventB = SupportBean.class.getName();

    String joinStatement =
        "select s0.doubleBoxed, s1.intPrimitive*s1.intBoxed/2.0 as div from "
            + eventA
            + "(theString='s0').win:length(3) as s0,"
            + eventB
            + "(theString='s1').win:length(3) as s1"
            + " where s0.doubleBoxed = s1.doubleBoxed";

    EPStatement joinView = epService.getEPAdministrator().createEPL(joinStatement);
    joinView.addListener(updateListener);

    EventType result = joinView.getEventType();
    assertEquals(Double.class, result.getPropertyType("s0.doubleBoxed"));
    assertEquals(Double.class, result.getPropertyType("div"));
    assertEquals(2, joinView.getEventType().getPropertyNames().length);

    assertNull(updateListener.getLastNewData());

    sendEvent("s0", 1, 4, 5);
    sendEvent("s1", 1, 3, 2);

    EventBean[] newEvents = updateListener.getLastNewData();
    assertEquals(1d, newEvents[0].get("s0.doubleBoxed"));
    assertEquals(3d, newEvents[0].get("div"));

    Iterator<EventBean> iterator = joinView.iterator();
    EventBean theEvent = iterator.next();
    assertEquals(1d, theEvent.get("s0.doubleBoxed"));
    assertEquals(3d, theEvent.get("div"));
  }
Esempio n. 6
0
  private void configureVariables() {

    provider.getEPAdministrator().getConfiguration().addVariable("myintvar", int.class, 5);

    EPStatement stmt =
        provider
            .getEPAdministrator()
            .createEPL("select propertyOne, propertyTwo, myintvar from MyEvent");

    // send an event
    Map<String, Object> eventData = new HashMap<String, Object>();
    eventData.put("propertyOne", "value");
    eventData.put("propertyTwo", 10);
    provider.getEPRuntime().sendEvent(eventData, "MyEvent");

    // the statement above keeps the last event for iterating
    EventBean received = stmt.iterator().next();
    System.out.println("\nConfigure Variables:");
    System.out.println(
        "Received:"
            + " propertyOne="
            + received.get("propertyOne")
            + " propertyTwo="
            + received.get("propertyTwo")
            + " myintvar="
            + received.get("myintvar"));
  }
Esempio n. 7
0
  private void configureVariantStream() {

    ConfigurationVariantStream variantStream = new ConfigurationVariantStream();
    variantStream.setTypeVariance(
        ConfigurationVariantStream.TypeVariance
            .ANY); // allow any type of event to be inserted into the stream

    // add variant stream
    provider
        .getEPAdministrator()
        .getConfiguration()
        .addVariantStream("MyVariantStream", variantStream);

    // keep the last few events from the variant stream
    EPStatement stmt =
        provider.getEPAdministrator().createEPL("select * from MyVariantStream.win:time(1 min)");

    // insert MyEvent events into the variant stream
    provider.getEPAdministrator().createEPL("insert into MyVariantStream select * from MyEvent");

    // Add a second event type
    Map<String, Object> typeDefinition = new HashMap<String, Object>();
    typeDefinition.put("propertyOther", String.class);
    provider.getEPAdministrator().getConfiguration().addEventType("MyOtherEvent", typeDefinition);

    // insert MyOtherEvent events into the variant stream
    provider
        .getEPAdministrator()
        .createEPL("insert into MyVariantStream select * from MyOtherEvent");

    // send some events
    Map<String, Object> eventData = new HashMap<String, Object>();
    eventData.put("propertyOne", "value");
    eventData.put("propertyTwo", 10);
    provider.getEPRuntime().sendEvent(eventData, "MyEvent");

    eventData = new HashMap<String, Object>();
    eventData.put("propertyOther", "test");
    provider.getEPRuntime().sendEvent(eventData, "MyOtherEvent");

    // print results
    System.out.println("\nConfigure Variant Stream:");
    Iterator<EventBean> iterator = stmt.iterator();
    EventBean first = iterator.next();
    System.out.println(
        "Received (1):"
            + " propertyOne="
            + first.get("propertyOne")
            + " propertyOther="
            + first.get("propertyOther"));

    EventBean second = iterator.next();
    System.out.println(
        "Received (2):"
            + " propertyOne="
            + second.get("propertyOne")
            + " propertyOther="
            + second.get("propertyOther"));
  }
 private void runAssertionIterateCreateTable(
     Object[][] expectedType, Object[] rowValues, EPStatement stmtCreate) {
   assertEventTypeAndEvent(
       stmtCreate.getEventType(),
       expectedType,
       stmtCreate.iterator().next().getUnderlying(),
       rowValues);
 }
  public void testVariableMoreThenOnce() {
    Configuration config = SupportConfigFactory.getConfiguration();
    config.addEventType("MyEvent", SupportRecogBean.class);
    EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider(config);
    epService.initialize();

    String[] fields = "a0,b,a1".split(",");
    String text =
        "select * from MyEvent.win:keepall() "
            + "match_recognize ("
            + "  measures A[0].theString as a0, B.theString as b, A[1].theString as a1 "
            + "  all matches "
            + "  after match skip to next row "
            + "  pattern ( A B A ) "
            + "  define "
            + "    A as (A.value = 1),"
            + "    B as (B.value = 2)"
            + ")";

    EPStatement stmt = epService.getEPAdministrator().createEPL(text);
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E1", 3));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E2", 1));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E3", 2));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E4", 5));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E5", 1));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E6", 2));
    assertFalse(listener.isInvoked());
    assertFalse(stmt.iterator().hasNext());

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E7", 1));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"E5", "E6", "E7"}});
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"E5", "E6", "E7"}});

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E8", 2));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E9", 1));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"E7", "E8", "E9"}});
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(), fields, new Object[][] {{"E5", "E6", "E7"}, {"E7", "E8", "E9"}});
  }
Esempio n. 10
0
 public static final void readNamedWindow(EPServiceProvider provider) {
   EPStatement statement =
       provider
           .getEPAdministrator()
           .createEPL(properties.getProperty("deposit.window.named1.select"));
   Iterator<EventBean> iterator = statement.iterator();
   while (iterator.hasNext()) {
     EventBean bean = iterator.next();
     System.out.println(bean.get("accountName"));
   }
 }
Esempio n. 11
0
  private void runAssertionPerformance(boolean namedWindow, EventRepresentationEnum outputType) {

    String eplCreate =
        namedWindow
            ? outputType.getAnnotationText()
                + " create window MyWindow.win:keepall() as (c1 string, c2 int)"
            : "create table MyWindow(c1 string primary key, c2 int)";
    EPStatement stmtNamedWindow = epService.getEPAdministrator().createEPL(eplCreate);
    assertEquals(outputType.getOutputClass(), stmtNamedWindow.getEventType().getUnderlyingType());

    // preload events
    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "insert into MyWindow select theString as c1, intPrimitive as c2 from SupportBean");
    final int totalUpdated = 5000;
    for (int i = 0; i < totalUpdated; i++) {
      epService.getEPRuntime().sendEvent(new SupportBean("E" + i, 0));
    }
    stmt.destroy();

    String epl =
        "on SupportBean sb merge MyWindow nw where nw.c1 = sb.theString "
            + "when matched then update set nw.c2=sb.intPrimitive";
    stmt = epService.getEPAdministrator().createEPL(epl);
    stmt.addListener(mergeListener);

    // prime
    for (int i = 0; i < 100; i++) {
      epService.getEPRuntime().sendEvent(new SupportBean("E" + i, 1));
    }
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < totalUpdated; i++) {
      epService.getEPRuntime().sendEvent(new SupportBean("E" + i, 1));
    }
    long endTime = System.currentTimeMillis();
    long delta = endTime - startTime;

    // verify
    Iterator<EventBean> events = stmtNamedWindow.iterator();
    int count = 0;
    for (; events.hasNext(); ) {
      EventBean next = events.next();
      assertEquals(1, next.get("c2"));
      count++;
    }
    assertEquals(totalUpdated, count);
    assertTrue("Delta=" + delta, delta < 500);

    epService.getEPAdministrator().destroyAllStatements();
    epService.getEPAdministrator().getConfiguration().removeEventType("MyWindow", true);
  }
Esempio n. 12
0
  private void configureSingleRowFunction() {
    // define a single-row median function provided by this class
    provider
        .getEPAdministrator()
        .getConfiguration()
        .addPlugInSingleRowFunction("mymedian", this.getClass().getName(), "computeDoubleMedian");

    // Add an event type that has a double-array -type property value
    Map<String, Object> typeDefinition = new HashMap<String, Object>();
    typeDefinition.put("doubles", double[].class);
    provider
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyMedianSampleEvent", typeDefinition);

    // keep the last few events from the variant stream
    EPStatement stmt =
        provider
            .getEPAdministrator()
            .createEPL("select mymedian(doubles) as med from MyMedianSampleEvent");

    // send an event
    Map<String, Object> eventData = new HashMap<String, Object>();
    eventData.put("doubles", new double[] {5, 1, 2, 3, 4});
    provider.getEPRuntime().sendEvent(eventData, "MyMedianSampleEvent");

    // print results
    System.out.println("\nConfigure Single-Row Function:");
    System.out.println("Received:" + " med=" + stmt.iterator().next().get("med"));

    // send a second event
    eventData = new HashMap<String, Object>();
    eventData.put("doubles", new double[] {5, 1, 2, 3, 4, 4});
    provider.getEPRuntime().sendEvent(eventData, "MyMedianSampleEvent");

    // print results
    System.out.println("Received:" + " med=" + stmt.iterator().next().get("med"));
  }
Esempio n. 13
0
  private void configureCustomAggregationFunction() {
    // define a append-string aggregation function provided by another class
    provider
        .getEPAdministrator()
        .getConfiguration()
        .addPlugInAggregationFunction("concat", MyConcatAggregationFunction.class.getName());

    // Add an event type that has a string-type property value
    Map<String, Object> typeDefinition = new HashMap<String, Object>();
    typeDefinition.put("str", String.class);
    provider
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("MyConcatSampleEvent", typeDefinition);

    // keep the last few events from the variant stream
    EPStatement stmt =
        provider
            .getEPAdministrator()
            .createEPL("select concat(str) as cstr from MyConcatSampleEvent");

    // send an event
    Map<String, Object> eventData = new HashMap<String, Object>();
    eventData.put("str", "part1");
    provider.getEPRuntime().sendEvent(eventData, "MyConcatSampleEvent");

    // print results
    System.out.println("\nConfigure Aggregation Function:");
    System.out.println("Received:" + " cstr=" + stmt.iterator().next().get("cstr"));

    // send a second event
    eventData = new HashMap<String, Object>();
    eventData.put("str", "part2");
    provider.getEPRuntime().sendEvent(eventData, "MyConcatSampleEvent");

    // print results
    System.out.println("Received:" + " cstr=" + stmt.iterator().next().get("cstr"));
  }
  public void testSkipToNextRow() {
    Configuration config = SupportConfigFactory.getConfiguration();
    config.addEventType("MyEvent", SupportRecogBean.class);
    EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider(config);
    epService.initialize();

    String[] fields = "a_string,b_string".split(",");
    String text =
        "select * from MyEvent.win:keepall() "
            + "match_recognize ("
            + "  measures A.theString as a_string, B.theString as b_string "
            + "  all matches "
            + "  after match skip to next row "
            + "  pattern (A B) "
            + "  define B as B.value > A.value"
            + ") "
            + "order by a_string, b_string";

    EPStatement stmt = epService.getEPAdministrator().createEPL(text);
    SupportUpdateListener listener = new SupportUpdateListener();
    stmt.addListener(listener);

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E1", 5));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E2", 3));
    assertFalse(listener.isInvoked());
    assertFalse(stmt.iterator().hasNext());

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E3", 6));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"E2", "E3"}});
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"E2", "E3"}});

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E4", 4));
    assertFalse(listener.isInvoked());
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), fields, new Object[][] {{"E2", "E3"}});

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E5", 6));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"E4", "E5"}});
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(), fields, new Object[][] {{"E2", "E3"}, {"E4", "E5"}});

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E6", 10));
    EPAssertionUtil.assertPropsPerRow(
        listener.getAndResetLastNewData(), fields, new Object[][] {{"E5", "E6"}});
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(), fields, new Object[][] {{"E2", "E3"}, {"E4", "E5"}, {"E5", "E6"}});

    epService.getEPRuntime().sendEvent(new SupportRecogBean("E7", 9));
    epService.getEPRuntime().sendEvent(new SupportRecogBean("E8", 4));
    assertFalse(listener.isInvoked());
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(), fields, new Object[][] {{"E2", "E3"}, {"E4", "E5"}, {"E5", "E6"}});

    stmt.stop();
  }
Esempio n. 15
0
  public void testReclaimAgedHint() {
    epService.getEPRuntime().sendEvent(new CurrentTimeEvent(0));
    epService
        .getEPAdministrator()
        .getConfiguration()
        .addEventType("SupportBean", SupportBean.class);
    String epl =
        "@Hint('reclaim_group_aged=5,reclaim_group_freq=1') "
            + "select * from SupportBean.std:groupwin(theString).win:keepall()";
    EPStatement stmt = epService.getEPAdministrator().createEPL(epl);

    int maxSlots = 10;
    int maxEventsPerSlot = 1000;
    for (int timeSlot = 0; timeSlot < maxSlots; timeSlot++) {
      epService.getEPRuntime().sendEvent(new CurrentTimeEvent(timeSlot * 1000 + 1));

      for (int i = 0; i < maxEventsPerSlot; i++) {
        epService.getEPRuntime().sendEvent(new SupportBean("E" + timeSlot, 0));
      }
    }

    EventBean[] iterator = EPAssertionUtil.iteratorToArray(stmt.iterator());
    assertTrue(iterator.length <= 6 * maxEventsPerSlot);
  }
Esempio n. 16
0
  public void testRevision() {
    EPStatement consumerOne = epService.getEPAdministrator().createEPL("select * from RevQuote");
    consumerOne.addListener(listenerOne);
    EPStatement consumerTwo =
        epService
            .getEPAdministrator()
            .createEPL(
                "select k0, count(*) as count, sum(Long.parseLong(p0)) as sum from RevQuote group by k0");
    consumerTwo.addListener(listenerTwo);
    EPStatement consumerThree =
        epService.getEPAdministrator().createEPL("select * from RevQuote output every 2 events");
    consumerThree.addListener(listenerThree);
    String[] agg = "k0,count,sum".split(",");

    epService
        .getEPRuntime()
        .sendEvent(new SupportRevisionFull("k00", "01", "p10", "20", "p30", "40", "50"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "01", "p10", "20", "p30", "40", "50"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "01", "p10", "20", "p30", "40", "50"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 1L});
    assertFalse(listenerThree.isInvoked());

    epService.getEPRuntime().sendEvent(new SupportDeltaThree("k00", "03", "41"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "03", "p10", "20", "p30", "41", "50"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "03", "p10", "20", "p30", "41", "50"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 3L});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[0],
        fields,
        new Object[] {"k00", "01", "p10", "20", "p30", "40", "50"});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[1],
        fields,
        new Object[] {"k00", "03", "p10", "20", "p30", "41", "50"});
    listenerThree.reset();

    epService.getEPRuntime().sendEvent(new SupportDeltaOne("k00", "p11", "51"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "03", "p11", "20", "p30", "41", "51"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "03", "p11", "20", "p30", "41", "51"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 3L});
    assertFalse(listenerThree.isInvoked());

    epService.getEPRuntime().sendEvent(new SupportDeltaTwo("k00", "04", "21", "p31"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "04", "p11", "21", "p31", "41", "51"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "04", "p11", "21", "p31", "41", "51"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 4L});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[0],
        fields,
        new Object[] {"k00", "03", "p11", "20", "p30", "41", "51"});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[1],
        fields,
        new Object[] {"k00", "04", "p11", "21", "p31", "41", "51"});
    listenerThree.reset();

    epService.getEPRuntime().sendEvent(new SupportDeltaFour("k00", "05", "22", "52"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "05", "p11", "22", "p31", "41", "52"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "05", "p11", "22", "p31", "41", "52"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 5L});
    assertFalse(listenerThree.isInvoked());

    epService.getEPRuntime().sendEvent(new SupportDeltaFive("k00", "p12", "53"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "05", "p12", "22", "p31", "41", "53"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "05", "p12", "22", "p31", "41", "53"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 5L});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[0],
        fields,
        new Object[] {"k00", "05", "p11", "22", "p31", "41", "52"});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[1],
        fields,
        new Object[] {"k00", "05", "p12", "22", "p31", "41", "53"});
    listenerThree.reset();

    epService
        .getEPRuntime()
        .sendEvent(new SupportRevisionFull("k00", "06", "p13", "23", "p32", "42", "54"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "06", "p13", "23", "p32", "42", "54"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "06", "p13", "23", "p32", "42", "54"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 6L});
    assertFalse(listenerThree.isInvoked());

    epService.getEPRuntime().sendEvent(new SupportDeltaOne("k00", "p14", "55"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"k00", "06", "p14", "23", "p32", "42", "55"});
    ArrayAssertionUtil.assertProps(
        stmtCreateWin.iterator().next(),
        fields,
        new Object[] {"k00", "06", "p14", "23", "p32", "42", "55"});
    ArrayAssertionUtil.assertProps(
        listenerTwo.assertOneGetNewAndReset(), agg, new Object[] {"k00", 1L, 6L});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[0],
        fields,
        new Object[] {"k00", "06", "p13", "23", "p32", "42", "54"});
    ArrayAssertionUtil.assertProps(
        listenerThree.getLastNewData()[1],
        fields,
        new Object[] {"k00", "06", "p14", "23", "p32", "42", "55"});
    listenerThree.reset();
  }
Esempio n. 17
0
  public void testStats() {
    EPAdministrator epAdmin = epService.getEPAdministrator();
    String filter = "select * from " + SupportMarketDataBean.class.getName();

    EPStatement priceLast3Stats =
        epAdmin.createEPL(filter + ".std:groupwin(symbol).win:length(3).stat:uni(price)");
    priceLast3Stats.addListener(priceLast3StatsListener);

    EPStatement volumeLast3Stats =
        epAdmin.createEPL(filter + ".std:groupwin(symbol).win:length(3).stat:uni(volume)");
    volumeLast3Stats.addListener(volumeLast3StatsListener);

    EPStatement priceAllStats = epAdmin.createEPL(filter + ".std:groupwin(symbol).stat:uni(price)");
    priceAllStats.addListener(priceAllStatsListener);

    EPStatement volumeAllStats =
        epAdmin.createEPL(filter + ".std:groupwin(symbol).stat:uni(volume)");
    volumeAllStats.addListener(volumeAllStatsListener);

    Vector<Map<String, Object>> expectedList = new Vector<Map<String, Object>>();
    for (int i = 0; i < 3; i++) {
      expectedList.add(new HashMap<String, Object>());
    }

    sendEvent(SYMBOL_CISCO, 25, 50000);
    sendEvent(SYMBOL_CISCO, 26, 60000);
    sendEvent(SYMBOL_IBM, 10, 8000);
    sendEvent(SYMBOL_IBM, 10.5, 8200);
    sendEvent(SYMBOL_GE, 88, 1000);

    EPAssertionUtil.assertPropsPerRow(
        priceLast3StatsListener.getLastNewData(), makeMap(SYMBOL_GE, 88));
    EPAssertionUtil.assertPropsPerRow(
        priceAllStatsListener.getLastNewData(), makeMap(SYMBOL_GE, 88));
    EPAssertionUtil.assertPropsPerRow(
        volumeLast3StatsListener.getLastNewData(), makeMap(SYMBOL_GE, 1000));
    EPAssertionUtil.assertPropsPerRow(
        volumeAllStatsListener.getLastNewData(), makeMap(SYMBOL_GE, 1000));

    sendEvent(SYMBOL_CISCO, 27, 70000);
    sendEvent(SYMBOL_CISCO, 28, 80000);

    EPAssertionUtil.assertPropsPerRow(
        priceAllStatsListener.getLastNewData(), makeMap(SYMBOL_CISCO, 26.5d));
    EPAssertionUtil.assertPropsPerRow(
        volumeAllStatsListener.getLastNewData(), makeMap(SYMBOL_CISCO, 65000d));
    EPAssertionUtil.assertPropsPerRow(
        priceLast3StatsListener.getLastNewData(), makeMap(SYMBOL_CISCO, 27d));
    EPAssertionUtil.assertPropsPerRow(
        volumeLast3StatsListener.getLastNewData(), makeMap(SYMBOL_CISCO, 70000d));

    sendEvent(SYMBOL_IBM, 11, 8700);
    sendEvent(SYMBOL_IBM, 12, 8900);

    EPAssertionUtil.assertPropsPerRow(
        priceAllStatsListener.getLastNewData(), makeMap(SYMBOL_IBM, 10.875d));
    EPAssertionUtil.assertPropsPerRow(
        volumeAllStatsListener.getLastNewData(), makeMap(SYMBOL_IBM, 8450d));
    EPAssertionUtil.assertPropsPerRow(
        priceLast3StatsListener.getLastNewData(), makeMap(SYMBOL_IBM, 11d + 1 / 6d));
    EPAssertionUtil.assertPropsPerRow(
        volumeLast3StatsListener.getLastNewData(), makeMap(SYMBOL_IBM, 8600d));

    sendEvent(SYMBOL_GE, 85.5, 950);
    sendEvent(SYMBOL_GE, 85.75, 900);
    sendEvent(SYMBOL_GE, 89, 1250);
    sendEvent(SYMBOL_GE, 86, 1200);
    sendEvent(SYMBOL_GE, 85, 1150);

    double averageGE = (88d + 85.5d + 85.75d + 89d + 86d + 85d) / 6d;
    EPAssertionUtil.assertPropsPerRow(
        priceAllStatsListener.getLastNewData(), makeMap(SYMBOL_GE, averageGE));
    EPAssertionUtil.assertPropsPerRow(
        volumeAllStatsListener.getLastNewData(), makeMap(SYMBOL_GE, 1075d));
    EPAssertionUtil.assertPropsPerRow(
        priceLast3StatsListener.getLastNewData(), makeMap(SYMBOL_GE, 86d + 2d / 3d));
    EPAssertionUtil.assertPropsPerRow(
        volumeLast3StatsListener.getLastNewData(), makeMap(SYMBOL_GE, 1200d));

    // Check iterator results
    expectedList.get(0).put("symbol", SYMBOL_CISCO);
    expectedList.get(0).put("average", 26.5d);
    expectedList.get(1).put("symbol", SYMBOL_IBM);
    expectedList.get(1).put("average", 10.875d);
    expectedList.get(2).put("symbol", SYMBOL_GE);
    expectedList.get(2).put("average", averageGE);
    EPAssertionUtil.assertPropsPerRow(priceAllStats.iterator(), expectedList);

    expectedList.get(0).put("symbol", SYMBOL_CISCO);
    expectedList.get(0).put("average", 27d);
    expectedList.get(1).put("symbol", SYMBOL_IBM);
    expectedList.get(1).put("average", 11d + 1 / 6d);
    expectedList.get(2).put("symbol", SYMBOL_GE);
    expectedList.get(2).put("average", 86d + 2d / 3d);
    EPAssertionUtil.assertPropsPerRow(priceLast3Stats.iterator(), expectedList);
  }
  public void testIterateStatement() {
    epService
        .getEPAdministrator()
        .createEPL("create context PartitionedByString partition by theString from SupportBean");
    String[] fields = "c0,c1".split(",");
    EPStatement stmt =
        epService
            .getEPAdministrator()
            .createEPL(
                "@Name('StmtOne') context PartitionedByString select context.key1 as c0, sum(intPrimitive) as c1 from SupportBean.win:length(5)");

    epService.getEPRuntime().sendEvent(new SupportBean("E1", 10));
    epService.getEPRuntime().sendEvent(new SupportBean("E2", 20));
    epService.getEPRuntime().sendEvent(new SupportBean("E2", 21));

    Object[][] expectedAll = new Object[][] {{"E1", 10}, {"E2", 41}};
    EPAssertionUtil.assertPropsPerRow(stmt.iterator(), stmt.safeIterator(), fields, expectedAll);

    // test iterator ALL
    ContextPartitionSelector selector = ContextPartitionSelectorAll.INSTANCE;
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(selector), stmt.safeIterator(selector), fields, expectedAll);

    // test iterator by context partition id
    selector = new SupportSelectorById(new HashSet<Integer>(Arrays.asList(0, 1, 2)));
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(selector), stmt.safeIterator(selector), fields, expectedAll);

    selector = new SupportSelectorById(new HashSet<Integer>(Arrays.asList(1)));
    EPAssertionUtil.assertPropsPerRow(
        stmt.iterator(selector), stmt.safeIterator(selector), fields, new Object[][] {{"E2", 41}});

    assertFalse(stmt.iterator(new SupportSelectorById(Collections.<Integer>emptySet())).hasNext());
    assertFalse(stmt.iterator(new SupportSelectorById(null)).hasNext());

    try {
      stmt.iterator(null);
      fail();
    } catch (IllegalArgumentException ex) {
      assertEquals(ex.getMessage(), "No selector provided");
    }

    try {
      stmt.safeIterator(null);
      fail();
    } catch (IllegalArgumentException ex) {
      assertEquals(ex.getMessage(), "No selector provided");
    }

    EPStatement stmtTwo =
        epService.getEPAdministrator().createEPL("select * from java.lang.Object");
    try {
      stmtTwo.iterator(null);
      fail();
    } catch (UnsupportedOperationException ex) {
      assertEquals(
          ex.getMessage(),
          "Iterator with context selector is only supported for statements under context");
    }

    try {
      stmtTwo.safeIterator(null);
      fail();
    } catch (UnsupportedOperationException ex) {
      assertEquals(
          ex.getMessage(),
          "Iterator with context selector is only supported for statements under context");
    }
  }
Esempio n. 19
0
  private void configureRevisionType() {
    // Declare two types: a base type and an update type

    // Define a type for the base events
    Map<String, Object> baseTypeDef = new HashMap<String, Object>();
    baseTypeDef.put("itemId", "string");
    baseTypeDef.put("category", "string");
    baseTypeDef.put("description", "string");
    baseTypeDef.put("price", "double");
    provider.getEPAdministrator().getConfiguration().addEventType("MyBaseEvent", baseTypeDef);

    // Define a type for the update/delta events
    Map<String, Object> updateTypeDef = new HashMap<String, Object>();
    updateTypeDef.put("itemId", "string");
    updateTypeDef.put("price", "double"); // price is updated
    provider.getEPAdministrator().getConfiguration().addEventType("MyUpdateEvent", updateTypeDef);

    // Define revision event type
    ConfigurationRevisionEventType config = new ConfigurationRevisionEventType();
    config.setKeyPropertyNames(new String[] {"itemId"});
    config.addNameBaseEventType("MyBaseEvent");
    config.addNameDeltaEventType("MyUpdateEvent");
    provider.getEPAdministrator().getConfiguration().addRevisionEventType("MyRevisionType", config);

    // Create a statement to keep the last event per item
    EPStatement stmt =
        provider
            .getEPAdministrator()
            .createEPL("create window ItemWindow.std:unique(itemId) select * from MyRevisionType");
    provider.getEPAdministrator().createEPL("insert into ItemWindow select * from MyBaseEvent");
    provider.getEPAdministrator().createEPL("insert into ItemWindow select * from MyUpdateEvent");

    // Send some base events and some update events
    Map<String, Object> baseEvent1 = makeBaseEvent("item1", "stockorder", "GE 100", 20d);
    provider.getEPRuntime().sendEvent(baseEvent1, "MyBaseEvent");

    Map<String, Object> baseEvent2 =
        makeBaseEvent("item2", "basketorder", "Basket of IBM-100 MSFT-200", 25d);
    provider.getEPRuntime().sendEvent(baseEvent2, "MyBaseEvent");

    Map<String, Object> updateEvent1 = makeUpdateEvent("item1", 21.05d);
    provider.getEPRuntime().sendEvent(updateEvent1, "MyUpdateEvent");

    Map<String, Object> updateEvent2 = makeUpdateEvent("item2", 24.95d);
    provider.getEPRuntime().sendEvent(updateEvent2, "MyUpdateEvent");

    // print results
    System.out.println("\nConfigure Revision Type:");
    Iterator<EventBean> iterator = stmt.iterator();
    EventBean first = iterator.next();
    System.out.println(
        "Received (1):"
            + " itemId="
            + first.get("itemId")
            + " category="
            + first.get("category")
            + " price="
            + first.get("price"));

    EventBean second = iterator.next();
    System.out.println(
        "Received (2):"
            + " itemId="
            + second.get("itemId")
            + " category="
            + second.get("category")
            + " price="
            + second.get("price"));
  }
Esempio n. 20
0
  public void testOnDelete() {
    EPStatement consumerOne =
        epService.getEPAdministrator().createEPL("select irstream * from RevQuote");
    consumerOne.addListener(listenerOne);

    epService
        .getEPAdministrator()
        .createEPL("on SupportBean(intPrimitive=2) as sb delete from RevQuote where string = p2");

    log("a00");
    epService
        .getEPRuntime()
        .sendEvent(new SupportRevisionFull("a", "a00", "a10", "a20", "a30", "a40", "a50"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"a", "a00", "a10", "a20", "a30", "a40", "a50"});

    epService.getEPRuntime().sendEvent(new SupportDeltaThree("x", "03", "41"));
    assertFalse(listenerOne.isInvoked());

    epService
        .getEPAdministrator()
        .createEPL("on SupportBean(intPrimitive=3) as sb delete from RevQuote where string = p3");

    log("b00");
    epService
        .getEPRuntime()
        .sendEvent(new SupportRevisionFull("b", "b00", "b10", "b20", "b30", "b40", "b50"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"b", "b00", "b10", "b20", "b30", "b40", "b50"});

    log("a01");
    epService.getEPRuntime().sendEvent(new SupportDeltaThree("a", "a01", "a41"));
    ArrayAssertionUtil.assertProps(
        listenerOne.getLastNewData()[0],
        fields,
        new Object[] {"a", "a01", "a10", "a20", "a30", "a41", "a50"});
    ArrayAssertionUtil.assertProps(
        listenerOne.getLastOldData()[0],
        fields,
        new Object[] {"a", "a00", "a10", "a20", "a30", "a40", "a50"});
    listenerOne.reset();

    log("c00");
    epService
        .getEPRuntime()
        .sendEvent(new SupportRevisionFull("c", "c00", "c10", "c20", "c30", "c40", "c50"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"c", "c00", "c10", "c20", "c30", "c40", "c50"});

    epService
        .getEPAdministrator()
        .createEPL("on SupportBean(intPrimitive=0) as sb delete from RevQuote where string = p0");

    log("c11");
    epService.getEPRuntime().sendEvent(new SupportDeltaFive("c", "c11", "c51"));
    ArrayAssertionUtil.assertProps(
        listenerOne.getLastNewData()[0],
        fields,
        new Object[] {"c", "c00", "c11", "c20", "c30", "c40", "c51"});
    ArrayAssertionUtil.assertProps(
        listenerOne.getLastOldData()[0],
        fields,
        new Object[] {"c", "c00", "c10", "c20", "c30", "c40", "c50"});
    listenerOne.reset();

    epService
        .getEPAdministrator()
        .createEPL("on SupportBean(intPrimitive=1) as sb delete from RevQuote where string = p1");

    log("d00");
    epService
        .getEPRuntime()
        .sendEvent(new SupportRevisionFull("d", "d00", "d10", "d20", "d30", "d40", "d50"));
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetNewAndReset(),
        fields,
        new Object[] {"d", "d00", "d10", "d20", "d30", "d40", "d50"});

    log("d01");
    epService.getEPRuntime().sendEvent(new SupportDeltaFour("d", "d01", "d21", "d51"));
    ArrayAssertionUtil.assertProps(
        listenerOne.getLastNewData()[0],
        fields,
        new Object[] {"d", "d01", "d10", "d21", "d30", "d40", "d51"});
    ArrayAssertionUtil.assertProps(
        listenerOne.getLastOldData()[0],
        fields,
        new Object[] {"d", "d00", "d10", "d20", "d30", "d40", "d50"});
    listenerOne.reset();

    ArrayAssertionUtil.assertEqualsExactOrder(
        stmtCreateWin.iterator(),
        fields,
        new Object[][] {
          {"b", "b00", "b10", "b20", "b30", "b40", "b50"},
          {"a", "a01", "a10", "a20", "a30", "a41", "a50"},
          {"c", "c00", "c11", "c20", "c30", "c40", "c51"},
          {"d", "d01", "d10", "d21", "d30", "d40", "d51"}
        });

    epService
        .getEPAdministrator()
        .createEPL("on SupportBean(intPrimitive=4) as sb delete from RevQuote where string = p4");

    epService.getEPRuntime().sendEvent(new SupportBean("abc", 1));
    assertFalse(listenerOne.isInvoked());

    log("delete b");
    epService.getEPRuntime().sendEvent(new SupportBean("b40", 4)); // delete b
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetOldAndReset(),
        fields,
        new Object[] {"b", "b00", "b10", "b20", "b30", "b40", "b50"});
    ArrayAssertionUtil.assertEqualsExactOrder(
        stmtCreateWin.iterator(),
        fields,
        new Object[][] {
          {"a", "a01", "a10", "a20", "a30", "a41", "a50"},
          {"c", "c00", "c11", "c20", "c30", "c40", "c51"},
          {"d", "d01", "d10", "d21", "d30", "d40", "d51"}
        });

    log("delete d");
    epService.getEPRuntime().sendEvent(new SupportBean("d21", 2)); // delete d
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetOldAndReset(),
        fields,
        new Object[] {"d", "d01", "d10", "d21", "d30", "d40", "d51"});
    ArrayAssertionUtil.assertEqualsExactOrder(
        stmtCreateWin.iterator(),
        fields,
        new Object[][] {
          {"a", "a01", "a10", "a20", "a30", "a41", "a50"},
          {"c", "c00", "c11", "c20", "c30", "c40", "c51"}
        });

    log("delete a");
    epService.getEPRuntime().sendEvent(new SupportBean("a30", 3)); // delete a
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetOldAndReset(),
        fields,
        new Object[] {"a", "a01", "a10", "a20", "a30", "a41", "a50"});
    ArrayAssertionUtil.assertEqualsExactOrder(
        stmtCreateWin.iterator(),
        fields,
        new Object[][] {{"c", "c00", "c11", "c20", "c30", "c40", "c51"}});

    log("delete c");
    epService.getEPRuntime().sendEvent(new SupportBean("c11", 1)); // delete c
    ArrayAssertionUtil.assertProps(
        listenerOne.assertOneGetOldAndReset(),
        fields,
        new Object[] {"c", "c00", "c11", "c20", "c30", "c40", "c51"});
    ArrayAssertionUtil.assertEqualsExactOrder(stmtCreateWin.iterator(), fields, null);

    epService.getEPRuntime().sendEvent(new SupportBean("c11", 1));
    assertFalse(listenerOne.isInvoked());
  }